package com.sg.service.biz.app.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.app.req.*;
import com.sg.dto.biz.app.req.*;
import com.sg.dto.biz.app.res.*;
import com.sg.dto.integration.framework.QueryDirectInductionRecordListComReqDto;
import com.sg.dto.integration.framework.QueryDirectInductionRecordListComRespDto;
import com.sg.service.base.app.*;
import com.sg.service.biz.app.CycleTypeService;
import com.sg.service.biz.app.DashboardTargetContentService;
import com.sg.service.biz.app.SmallCircleCommonService;
import com.sg.common.exception.Assert;
import com.wicket.okrcomponent.integration.FwCompDashboardWorkTaskClient;
import com.wicket.okrcomponent.integration.DivineDataService;
import com.wicket.okrcomponent.integration.InterfaceModeService;
import com.wicket.okrcomponent.integration.dto.*;
import com.wicket.okrframework.integration.InductionRecordService;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class DashboardWorkTaskServiceImpl
        implements com.wicket.okrapp.biz.service.DashboardWorkTaskService {

    @Resource
    private RedisUtil redisUtil;
    //@Resource
    //private MCustomFields5Service mCustomFields5Service;
    @Resource
    private MOmsCycleService mOmsCycleService;
    @Resource
    private NbDashboardWorkTask nbDashboardWorkTask;
    @Resource
    private CycleTypeService cycleTypeService;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private InductionRecordService inductionRecordService;
    @Resource
    private DashboardTargetContentService dashboardTargetContentService;
    @Resource
    private MOmsQuestionService mOmsQuestionService;
    @Resource
    private SmallCircleCommonService smallCircleCommonService;
    @Resource
    private MOmsTaskService mOmsTaskService;
    @Resource
    private FwCompDashboardWorkTaskClient fwCompDashboardWorkTaskClient;
    @Resource
    private DivineDataService fwCompDivineDataClient;
    @Resource
    private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
    @Resource
    private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;

    /**
     * D3分析工作归属与更新周期及上一周期(公共)[8894]
     * gen by moon at 7/22/2024, 10:11:03 PM
     */
    @Trace(operationName = "D3分析工作归属与更新周期及上一周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisWorkBelongAndUpdatePreviousCycleComRespDto analysisWorkBelongAndUpdatePreviousCycleCom(AnalysisWorkBelongAndUpdatePreviousCycleComReqDto reqDto) {


        ImplementEightReceivingFieldRespDto receptionServiceRes_3 = null;
//virtualUsage M3约定系统当前时间  65402
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        receptionServiceReq.setComTimeField(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1663946_1_65402

        /*M3约定系统当前时间[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getComTimeField(), "D3分析工作归属与更新周期及上一周期(公共)-M3约定系统当前时间-通用时间字段不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//virtualUsage D3分析租户周期(公共)  65420
        AnalysisTenementCycleComRespDto analysisTenementCycleComRespDto = null;
        AnalysisTenementCycleComReqDto analysisTenementCycleComReqDto = new AnalysisTenementCycleComReqDto();
        if (reqDto != null) {
            analysisTenementCycleComReqDto.setIsTenementCycle(reqDto.getIsTenementCycle());//SimpleFieldAssign//sourceId:1664709_1_65420
            analysisTenementCycleComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1664740_1_65420
        }

        /*D3分析租户周期(公共)[8903]   */
        Assert.isNull(analysisTenementCycleComReqDto.getIsTenementCycle(), "D3分析工作归属与更新周期及上一周期(公共)-D3分析租户周期(公共)-是否租户周期不能为空", false);
        Assert.isNull(analysisTenementCycleComReqDto.getSpaceId(), "D3分析工作归属与更新周期及上一周期(公共)-D3分析租户周期(公共)-创建于空间ID不能为空", false);
        analysisTenementCycleComRespDto = cycleTypeService.analysisTenementCycleCom(analysisTenementCycleComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage 3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）  71865
        OmsCycle omsCycle = null;
        if (analysisTenementCycleComRespDto != null) {
            QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq = new QueryTimeRangeFindCycleDetailReq();
            if (receptionServiceRes != null) {
                queryTimeRangeFindCycleDetailReq.setCycleStartTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1948282_1_71865
                queryTimeRangeFindCycleDetailReq.setCycleEndTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1948283_1_71865
            }
            if (reqDto != null) {
                queryTimeRangeFindCycleDetailReq.setCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1948284_1_71865
            }
            if (analysisTenementCycleComRespDto != null) {
                queryTimeRangeFindCycleDetailReq.setPlatformData(analysisTenementCycleComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:1948285_1_71865
                queryTimeRangeFindCycleDetailReq.setSpaceId(analysisTenementCycleComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1948294_1_71865
            }

            /*3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）[7005]   */
            Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleStartTime(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期开始时间不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleEndTime(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期结束时间不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleTypeCode(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期类型标识不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq.getPlatformData(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否是平台不能为空", false);
            omsCycle = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        }
//virtualUsage 3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）  71866
        OmsCycle omsCycle_2 = null;
        if (analysisTenementCycleComRespDto != null) {
            QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq_1 = new QueryTimeRangeFindCycleDetailReq();
            if (receptionServiceRes != null) {
                queryTimeRangeFindCycleDetailReq_1.setCycleStartTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1948282_1_71866
                queryTimeRangeFindCycleDetailReq_1.setCycleEndTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1948283_1_71866
            }
            if (reqDto != null) {
                queryTimeRangeFindCycleDetailReq_1.setCycleTypeCode(reqDto.getWorkCycleTypeCode());//SimpleFieldAssign//sourceId:1948284_1_71866
                queryTimeRangeFindCycleDetailReq_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1948294_1_71866
            }
            if (analysisTenementCycleComRespDto != null) {
                queryTimeRangeFindCycleDetailReq_1.setPlatformData(analysisTenementCycleComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:1948285_1_71866
            }

            /*3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）[7005]   */
            Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getCycleStartTime(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期开始时间不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getCycleEndTime(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期结束时间不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getCycleTypeCode(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期类型标识不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getPlatformData(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否是平台不能为空", false);
            omsCycle_2 = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


        }
//virtualUsage D2更新周期开始时间减1秒（用于查上一周期ID）  65405
        ImplementTimeAddAndSubComRespDto implementTimeAddAndSubComRespDto = null;
        if (omsCycle != null) {
            ImplementTimeAddAndSubComReqDto implementTimeAddAndSubComReqDto = new ImplementTimeAddAndSubComReqDto();
            implementTimeAddAndSubComReqDto.setComNumField(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1664067_1_65405
            implementTimeAddAndSubComReqDto.setCalcFormula("SUBTRACTION_OF_TWO_NUM");//sourceId:1664065_1_65405
            implementTimeAddAndSubComReqDto.setTimeUnitType("SECOND");//sourceId:1664066_1_65405
            if (omsCycle != null) {
                implementTimeAddAndSubComReqDto.setComTimeField(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1664064_1_65405
            }

            /*D2更新周期开始时间减1秒（用于查上一周期ID）[7369]   */
            Assert.isNull(implementTimeAddAndSubComReqDto.getComTimeField(), "D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-通用时间字段不能为空", false);
            Assert.isNull(implementTimeAddAndSubComReqDto.getComNumField(), "D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-通用数值字段（整数型）不能为空", false);
            Assert.isNull(implementTimeAddAndSubComReqDto.getCalcFormula(), "D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-通用计算公式不能为空", false);
            Assert.isNull(implementTimeAddAndSubComReqDto.getTimeUnitType(), "D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-时间单位类型不能为空", false);
            implementTimeAddAndSubComRespDto = interfaceModeService.implementTimeAddAndSubCom(implementTimeAddAndSubComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
//virtualUsage D2更新周期开始时间减1秒（用于查上一周期ID）  68474
        ImplementTimeAddAndSubComRespDto implementTimeAddAndSubComRespDto_2 = null;
        if (omsCycle_2 != null) {
            ImplementTimeAddAndSubComReqDto implementTimeAddAndSubComReqDto_1 = new ImplementTimeAddAndSubComReqDto();
            implementTimeAddAndSubComReqDto_1.setComNumField(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1664067_1_68474
            implementTimeAddAndSubComReqDto_1.setCalcFormula("SUBTRACTION_OF_TWO_NUM");//sourceId:1664065_1_68474
            implementTimeAddAndSubComReqDto_1.setTimeUnitType("SECOND");//sourceId:1664066_1_68474
            if (omsCycle_2 != null) {
                implementTimeAddAndSubComReqDto_1.setComTimeField(omsCycle_2.getCycleStartTime());//SimpleFieldAssign//sourceId:1664064_1_68474
            }

            /*D2更新周期开始时间减1秒（用于查上一周期ID）[7369]   */
            Assert.isNull(implementTimeAddAndSubComReqDto_1.getComTimeField(), "D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-通用时间字段不能为空", false);
            Assert.isNull(implementTimeAddAndSubComReqDto_1.getComNumField(), "D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-通用数值字段（整数型）不能为空", false);
            Assert.isNull(implementTimeAddAndSubComReqDto_1.getCalcFormula(), "D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-通用计算公式不能为空", false);
            Assert.isNull(implementTimeAddAndSubComReqDto_1.getTimeUnitType(), "D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-时间单位类型不能为空", false);
            implementTimeAddAndSubComRespDto_2 = interfaceModeService.implementTimeAddAndSubCom(implementTimeAddAndSubComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


        }
//virtualUsage 3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）  71867
        OmsCycle omsCycle_3 = null;
        if (implementTimeAddAndSubComRespDto != null && analysisTenementCycleComRespDto != null) {
            QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq_2 = new QueryTimeRangeFindCycleDetailReq();
            if (implementTimeAddAndSubComRespDto != null) {
                queryTimeRangeFindCycleDetailReq_2.setCycleStartTime(implementTimeAddAndSubComRespDto.getCalcTimeResult());//SimpleFieldAssign//sourceId:1948295_1_71867
                queryTimeRangeFindCycleDetailReq_2.setCycleEndTime(implementTimeAddAndSubComRespDto.getCalcTimeResult());//SimpleFieldAssign//sourceId:1948296_1_71867
            }
            if (reqDto != null) {
                queryTimeRangeFindCycleDetailReq_2.setCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1948297_1_71867
            }
            if (analysisTenementCycleComRespDto != null) {
                queryTimeRangeFindCycleDetailReq_2.setPlatformData(analysisTenementCycleComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:1948298_1_71867
                queryTimeRangeFindCycleDetailReq_2.setSpaceId(analysisTenementCycleComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1948307_1_71867
            }

            /*3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）[7005]   */
            Assert.isNull(queryTimeRangeFindCycleDetailReq_2.getCycleStartTime(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期开始时间不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq_2.getCycleEndTime(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期结束时间不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq_2.getCycleTypeCode(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期类型标识不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq_2.getPlatformData(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否是平台不能为空", false);
            omsCycle_3 = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


        }
//virtualUsage 3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）  71868
        OmsCycle omsCycle_5 = null;
        if (implementTimeAddAndSubComRespDto_2 != null && analysisTenementCycleComRespDto != null) {
            QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq_3 = new QueryTimeRangeFindCycleDetailReq();
            if (implementTimeAddAndSubComRespDto_2 != null) {
                queryTimeRangeFindCycleDetailReq_3.setCycleStartTime(implementTimeAddAndSubComRespDto_2.getCalcTimeResult());//SimpleFieldAssign//sourceId:1948295_1_71868
                queryTimeRangeFindCycleDetailReq_3.setCycleEndTime(implementTimeAddAndSubComRespDto_2.getCalcTimeResult());//SimpleFieldAssign//sourceId:1948296_1_71868
            }
            if (reqDto != null) {
                queryTimeRangeFindCycleDetailReq_3.setCycleTypeCode(reqDto.getWorkCycleTypeCode());//SimpleFieldAssign//sourceId:1948297_1_71868
            }
            if (analysisTenementCycleComRespDto != null) {
                queryTimeRangeFindCycleDetailReq_3.setPlatformData(analysisTenementCycleComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:1948298_1_71868
                queryTimeRangeFindCycleDetailReq_3.setSpaceId(analysisTenementCycleComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1948307_1_71868
            }

            /*3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）[7005]   */
            Assert.isNull(queryTimeRangeFindCycleDetailReq_3.getCycleStartTime(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期开始时间不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq_3.getCycleEndTime(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期结束时间不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq_3.getCycleTypeCode(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期类型标识不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq_3.getPlatformData(), "D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否是平台不能为空", false);
            omsCycle_5 = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq_3)/*vcase invoke 本地 method 方法调用;*/;


        }
//virtualUsage M3接收工作归属、更新及上一周期出参  65410
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes_2 = null;
        if (omsCycle_3 != null && omsCycle_5 != null && omsCycle_2 != null && omsCycle != null) {
            ImplementEightReceivingFieldReqDto receptionServiceReq_1 = new ImplementEightReceivingFieldReqDto();
            if (omsCycle_3 != null) {
                receptionServiceReq_1.setPreUpdateCycleId(omsCycle_3.getCycleId());//SimpleFieldAssign//sourceId:1801877_1_65410
            }
            if (omsCycle_5 != null) {
                receptionServiceReq_1.setPreviousCycleId(omsCycle_5.getCycleId());//SimpleFieldAssign//sourceId:1664059_1_65410
            }
            if (omsCycle_2 != null) {
                receptionServiceReq_1.setCycleId(omsCycle_2.getCycleId());//SimpleFieldAssign//sourceId:1664061_1_65410
                receptionServiceReq_1.setCycleStartTime(omsCycle_2.getCycleStartTime());//SimpleFieldAssign//sourceId:1664120_1_65410
                receptionServiceReq_1.setCycleEndTime(omsCycle_2.getCycleEndTime());//SimpleFieldAssign//sourceId:1664121_1_65410
                receptionServiceReq_1.setCycleTypeCode(omsCycle_2.getCycleTypeCode());//SimpleFieldAssign//sourceId:1664122_1_65410
                receptionServiceReq_1.setCycleTypeInstanceCode(omsCycle_2.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1664123_1_65410
            }
            if (omsCycle != null) {
                receptionServiceReq_1.setUpdateCycleId(omsCycle.getCycleId());//SimpleFieldAssign//sourceId:1664060_1_65410
                receptionServiceReq_1.setUpdateCycleStartTime(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1664124_1_65410
                receptionServiceReq_1.setUpdateCycleEndTime(omsCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:1664125_1_65410
                receptionServiceReq_1.setUpdateCycleTypeCode(omsCycle.getCycleTypeCode());//SimpleFieldAssign//sourceId:1664126_1_65410
            }

            /*M3接收工作归属、更新及上一周期出参[8691]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getCycleId(), "D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-归属周期ID不能为空", false);
            Assert.isNull(receptionServiceReq_1.getCycleStartTime(), "D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-周期开始时间不能为空", false);
            Assert.isNull(receptionServiceReq_1.getCycleEndTime(), "D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-周期结束时间不能为空", false);
            Assert.isNull(receptionServiceReq_1.getCycleTypeCode(), "D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-周期类型标识不能为空", false);
            Assert.isNull(receptionServiceReq_1.getUpdateCycleId(), "D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-更新周期ID不能为空", false);
            Assert.isNull(receptionServiceReq_1.getUpdateCycleStartTime(), "D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-更新周期开始时间不能为空", false);
            Assert.isNull(receptionServiceReq_1.getUpdateCycleEndTime(), "D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-更新周期结束时间不能为空", false);
            Assert.isNull(receptionServiceReq_1.getUpdateCycleTypeCode(), "D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-更新周期类型标识不能为空", false);
            receptionServiceRes_2 = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        }
        AnalysisWorkBelongAndUpdatePreviousCycleComRespDto retData = new AnalysisWorkBelongAndUpdatePreviousCycleComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setPreUpdateCycleId(receptionServiceRes_3.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1801885_1
            retData.setPreviousCycleId(receptionServiceRes_3.getPreviousCycleId());//SimpleFieldAssign//sourceId:1664171_1
            retData.setCycleId(receptionServiceRes_3.getCycleId());//SimpleFieldAssign//sourceId:1664172_1
            retData.setCycleStartTime(receptionServiceRes_3.getCycleStartTime());//SimpleFieldAssign//sourceId:1664173_1
            retData.setCycleEndTime(receptionServiceRes_3.getCycleEndTime());//SimpleFieldAssign//sourceId:1664174_1
            retData.setCycleTypeCode(receptionServiceRes_3.getCycleTypeCode());//SimpleFieldAssign//sourceId:1664175_1
            retData.setCycleTypeInstanceCode(receptionServiceRes_3.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1664176_1
            retData.setUpdateCycleId(receptionServiceRes_3.getUpdateCycleId());//SimpleFieldAssign//sourceId:1664177_1
            retData.setUpdateCycleStartTime(receptionServiceRes_3.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1664178_1
            retData.setUpdateCycleEndTime(receptionServiceRes_3.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1664179_1
            retData.setUpdateCycleTypeCode(receptionServiceRes_3.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1664180_1
        }


        return retData;
    }

    /**
     * D3查询部门下人员工作小圈子列表(公共)[8991]
     * gen by moon at 4/2/2024, 6:21:52 PM
     */
    @Trace(operationName = "D3查询部门下人员工作小圈子列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryDeptSubPersonnelSmallCircleListComRespDto queryDeptSubPersonnelSmallCircleListCom(QueryDeptSubPersonnelSmallCircleListComReqDto reqDto) {


        BatchQueryVirtualOrgMemberByinducRecIdComRespDto batchQueryVirtualOrgMemberByinducRecIdComRespDto_1 = null;
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1679597_1
            receptionServiceReq.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1680056_1
            receptionServiceReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1685207_1
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1685233_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679600_1
        }

        /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getDeptId(), "D3查询部门下人员工作小圈子列表(公共)-M3接收入参字段-部门ID不能为空", false);
        Assert.isNull(receptionServiceReq.getUseScene(), "D3查询部门下人员工作小圈子列表(公共)-M3接收入参字段-虚拟组织使用场景不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询部门下人员工作小圈子列表(公共)-M3接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D1-3查直属就职记录列表(公共) - queryDirectInductionRecordListCom
        QueryDirectInductionRecordListComRespDto queryDirectInductionRecordListComRespDto = null;
        QueryDirectInductionRecordListComReqDto queryDirectInductionRecordListComReqDto = new QueryDirectInductionRecordListComReqDto();
        queryDirectInductionRecordListComReqDto.setIsTransaction("FALSE");//sourceId:1679585_1
        queryDirectInductionRecordListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1679586_1
        if (reqDto != null) {
            queryDirectInductionRecordListComReqDto.setEntityId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1679580_1
            queryDirectInductionRecordListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679588_1
        }

        /*D1-3查直属就职记录列表(公共)[8057]   */
        Assert.isNull(queryDirectInductionRecordListComReqDto.getEntityId(), "D3查询部门下人员工作小圈子列表(公共)-D1-3查直属就职记录列表(公共)-就职单位对象实例ID不能为空", false);
        Assert.isNull(queryDirectInductionRecordListComReqDto.getIsTransaction(), "D3查询部门下人员工作小圈子列表(公共)-D1-3查直属就职记录列表(公共)-是否异动不能为空", false);
        Assert.isNull(queryDirectInductionRecordListComReqDto.getSubjectLifeCycle(), "D3查询部门下人员工作小圈子列表(公共)-D1-3查直属就职记录列表(公共)-主体生命周期不能为空", false);
        Assert.isNull(queryDirectInductionRecordListComReqDto.getSpaceId(), "D3查询部门下人员工作小圈子列表(公共)-D1-3查直属就职记录列表(公共)-创建于空间ID不能为空", false);
        queryDirectInductionRecordListComRespDto = inductionRecordService.queryDirectInductionRecordListCom(queryDirectInductionRecordListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤2: D3批量查询人员小圈子By就职记录(公共) - batchQueryVirtualOrgMemberByinducRecIdCom
        BatchQueryVirtualOrgMemberByinducRecIdComRespDto batchQueryVirtualOrgMemberByinducRecIdComRespDto = null;
        if (queryDirectInductionRecordListComRespDto != null) {
            BatchQueryVirtualOrgMemberByinducRecIdComReqDto batchQueryVirtualOrgMemberByinducRecIdComReqDto = new BatchQueryVirtualOrgMemberByinducRecIdComReqDto();
            batchQueryVirtualOrgMemberByinducRecIdComReqDto.setIsPersonCharge("TRUE");//sourceId:1679612_1
            batchQueryVirtualOrgMemberByinducRecIdComReqDto.setIsDisplay("TRUE");//sourceId:1679611_1
            if (queryDirectInductionRecordListComRespDto != null && queryDirectInductionRecordListComRespDto.getOrgInductionRecordList() != null && !CollectionUtil.isEmpty(queryDirectInductionRecordListComRespDto.getOrgInductionRecordList())) {
                batchQueryVirtualOrgMemberByinducRecIdComReqDto.setVirtualOrgMemberList(queryDirectInductionRecordListComRespDto.getOrgInductionRecordList().stream().map(item -> item.getInductionRecordId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1679605_1
            }
            if (reqDto != null) {
                batchQueryVirtualOrgMemberByinducRecIdComReqDto.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1679607_1
                batchQueryVirtualOrgMemberByinducRecIdComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1679610_1
                batchQueryVirtualOrgMemberByinducRecIdComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1685232_1
                batchQueryVirtualOrgMemberByinducRecIdComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679608_1
            }

            /*D3批量查询人员小圈子By就职记录(公共)[8872]   */
            Assert.isNull(batchQueryVirtualOrgMemberByinducRecIdComReqDto.getUseScene(), "D3查询部门下人员工作小圈子列表(公共)-D3批量查询人员小圈子By就职记录(公共)-虚拟组织使用场景不能为空", false);
            Assert.isNull(batchQueryVirtualOrgMemberByinducRecIdComReqDto.getIsPersonCharge(), "D3查询部门下人员工作小圈子列表(公共)-D3批量查询人员小圈子By就职记录(公共)-是否负责人不能为空", false);
            Assert.isNull(batchQueryVirtualOrgMemberByinducRecIdComReqDto.getIsDisplay(), "D3查询部门下人员工作小圈子列表(公共)-D3批量查询人员小圈子By就职记录(公共)-是否外部展示不能为空", false);
            Assert.isNull(batchQueryVirtualOrgMemberByinducRecIdComReqDto.getSpaceId(), "D3查询部门下人员工作小圈子列表(公共)-D3批量查询人员小圈子By就职记录(公共)-创建于空间ID不能为空", false);
            batchQueryVirtualOrgMemberByinducRecIdComRespDto = dashboardTargetContentService.batchQueryVirtualOrgMemberByinducRecIdCom(batchQueryVirtualOrgMemberByinducRecIdComReqDto)/*vcase invoke isSameApp*/;


            batchQueryVirtualOrgMemberByinducRecIdComRespDto_1 = batchQueryVirtualOrgMemberByinducRecIdComRespDto;
        }

        QueryDeptSubPersonnelSmallCircleListComRespDto retData = new QueryDeptSubPersonnelSmallCircleListComRespDto();
        if (batchQueryVirtualOrgMemberByinducRecIdComRespDto_1 != null) {
            retData.setVirtualOrgMemberList(batchQueryVirtualOrgMemberByinducRecIdComRespDto_1.getVirtualOrgMemberList().stream().map(item -> BeanUtil.toBean(item, VirtualOrgMemberDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1680060_1
        }


        return retData;
    }

    /**
     * D3查询个人问题解决时长排行列表[9009]
     * gen by moon at 4/1/2024, 1:57:08 AM
     */
    @Trace(operationName = "D3查询个人问题解决时长排行列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryPersonalQuestionSolveRankListRespDto queryPersonalQuestionSolveRankList(QueryPersonalQuestionSolveRankListReqDto reqDto) {


        List<OmsQuestion> listOmsQuestion_1 = new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1681435_1
            receptionServiceReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1681444_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681434_1
        }

        /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getOriginalRoleMemberId(), "D3查询个人问题解决时长排行列表-M3接收入参字段-身份人员ID不能为空", false);
        Assert.isNull(receptionServiceReq.getQuestionStatus(), "D3查询个人问题解决时长排行列表-M3接收入参字段-问题状态不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询个人问题解决时长排行列表-M3接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D3查询我身份所在小圈子列表(公共) - queryIdentitySmallCircleListCom
        QueryIdentitySmallCircleListComRespDto queryIdentitySmallCircleListComRespDto = null;
        QueryIdentitySmallCircleListComReqDto queryIdentitySmallCircleListComReqDto = new QueryIdentitySmallCircleListComReqDto();
        queryIdentitySmallCircleListComReqDto.setIsPersonCharge("TRUE");//sourceId:1681428_1
        queryIdentitySmallCircleListComReqDto.setTableTypeCode("OMS_QUESTION");//sourceId:1681429_1
        queryIdentitySmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1681430_1
        queryIdentitySmallCircleListComReqDto.setIsDisplay("TRUE");//sourceId:1681431_1
        queryIdentitySmallCircleListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1681432_1
        if (reqDto != null) {
            queryIdentitySmallCircleListComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1681427_1
            queryIdentitySmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681433_1
        }

        /*D3查入参身份人员负责的问题列表[8803]   */
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getOriginalRoleMemberId(), "D3查询个人问题解决时长排行列表-D3查入参身份人员负责的问题列表-身份人员ID不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsPersonCharge(), "D3查询个人问题解决时长排行列表-D3查入参身份人员负责的问题列表-是否负责人不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getTableTypeCode(), "D3查询个人问题解决时长排行列表-D3查入参身份人员负责的问题列表-冗余内容表类型编码不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getUseScene(), "D3查询个人问题解决时长排行列表-D3查入参身份人员负责的问题列表-虚拟组织使用场景不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsDisplay(), "D3查询个人问题解决时长排行列表-D3查入参身份人员负责的问题列表-是否外部展示不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getSubjectLifeCycle(), "D3查询个人问题解决时长排行列表-D3查入参身份人员负责的问题列表-主体生命周期不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getSpaceId(), "D3查询个人问题解决时长排行列表-D3查入参身份人员负责的问题列表-创建于空间ID不能为空", false);
        queryIdentitySmallCircleListComRespDto = smallCircleCommonService.queryIdentitySmallCircleListCom(queryIdentitySmallCircleListComReqDto)/*vcase invoke isSameApp*/;


//步骤2: 3-7-02批量查询问题解决天数排行 - batchQueryQuestionSolvesRank
        List<OmsQuestion> listOmsQuestion = new ArrayList<>();
        if (queryIdentitySmallCircleListComRespDto != null) {
            BatchQueryQuestionSolvesRankReq batchQueryQuestionSolvesRankReq = new BatchQueryQuestionSolvesRankReq();
            batchQueryQuestionSolvesRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1681440_1
            if (queryIdentitySmallCircleListComRespDto != null && queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList() != null && !CollectionUtil.isEmpty(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList())) {
                batchQueryQuestionSolvesRankReq.setQuestionList(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item -> item.getEntityId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1681438_1
            }
            if (reqDto != null) {
                batchQueryQuestionSolvesRankReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1681439_1
                batchQueryQuestionSolvesRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681441_1
            }

            /*3-7-02批量查询问题解决天数排行[9004]   */
            Assert.isNull(batchQueryQuestionSolvesRankReq.getQuestionStatus(), "D3查询个人问题解决时长排行列表-3-7-02批量查询问题解决天数排行-问题状态不能为空", false);
            Assert.isNull(batchQueryQuestionSolvesRankReq.getSubjectLifeCycle(), "D3查询个人问题解决时长排行列表-3-7-02批量查询问题解决天数排行-主体生命周期不能为空", false);
            Assert.isNull(batchQueryQuestionSolvesRankReq.getSpaceId(), "D3查询个人问题解决时长排行列表-3-7-02批量查询问题解决天数排行-创建于空间ID不能为空", false);
            listOmsQuestion = mOmsQuestionService.batchQueryQuestionSolvesRank(batchQueryQuestionSolvesRankReq)/*vcase invoke 本地 method 方法调用;*/;


            listOmsQuestion_1 = listOmsQuestion;
        }

        QueryPersonalQuestionSolveRankListRespDto retData = new QueryPersonalQuestionSolveRankListRespDto();
        retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1681446_1


        return retData;
    }

    /**
     * D3查询个人问题超时排行列表[9010]
     * gen by moon at 4/1/2024, 1:57:21 AM
     */
    @Trace(operationName = "D3查询个人问题超时排行列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryPersonalQuestionTimeoutRankListRespDto queryPersonalQuestionTimeoutRankList(QueryPersonalQuestionTimeoutRankListReqDto reqDto) {


        List<OmsQuestion> listOmsQuestion_1 = new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1681480_1
            receptionServiceReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1681482_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681481_1
        }

        /*M3接收字段入参[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getOriginalRoleMemberId(), "D3查询个人问题超时排行列表-M3接收字段入参-身份人员ID不能为空", false);
        Assert.isNull(receptionServiceReq.getQuestionStatus(), "D3查询个人问题超时排行列表-M3接收字段入参-问题状态不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询个人问题超时排行列表-M3接收字段入参-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D3查询我身份所在小圈子列表(公共) - queryIdentitySmallCircleListCom
        QueryIdentitySmallCircleListComRespDto queryIdentitySmallCircleListComRespDto = null;
        QueryIdentitySmallCircleListComReqDto queryIdentitySmallCircleListComReqDto = new QueryIdentitySmallCircleListComReqDto();
        queryIdentitySmallCircleListComReqDto.setIsPersonCharge("TRUE");//sourceId:1681469_1
        queryIdentitySmallCircleListComReqDto.setTableTypeCode("OMS_QUESTION");//sourceId:1681470_1
        queryIdentitySmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1681471_1
        queryIdentitySmallCircleListComReqDto.setIsDisplay("TRUE");//sourceId:1681472_1
        queryIdentitySmallCircleListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1681473_1
        if (reqDto != null) {
            queryIdentitySmallCircleListComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1681468_1
            queryIdentitySmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681474_1
        }

        /*D3查入参身份人员负责的问题列表[8803]   */
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getOriginalRoleMemberId(), "D3查询个人问题超时排行列表-D3查入参身份人员负责的问题列表-身份人员ID不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsPersonCharge(), "D3查询个人问题超时排行列表-D3查入参身份人员负责的问题列表-是否负责人不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getTableTypeCode(), "D3查询个人问题超时排行列表-D3查入参身份人员负责的问题列表-冗余内容表类型编码不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getUseScene(), "D3查询个人问题超时排行列表-D3查入参身份人员负责的问题列表-虚拟组织使用场景不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsDisplay(), "D3查询个人问题超时排行列表-D3查入参身份人员负责的问题列表-是否外部展示不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getSubjectLifeCycle(), "D3查询个人问题超时排行列表-D3查入参身份人员负责的问题列表-主体生命周期不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getSpaceId(), "D3查询个人问题超时排行列表-D3查入参身份人员负责的问题列表-创建于空间ID不能为空", false);
        queryIdentitySmallCircleListComRespDto = smallCircleCommonService.queryIdentitySmallCircleListCom(queryIdentitySmallCircleListComReqDto)/*vcase invoke isSameApp*/;


//步骤2: 3-7-02批量查询问题超时排行 - batchQueryQuestionTimeoutRank
        List<OmsQuestion> listOmsQuestion = new ArrayList<>();
        if (queryIdentitySmallCircleListComRespDto != null) {
            BatchQueryQuestionTimeoutRankReq batchQueryQuestionTimeoutRankReq = new BatchQueryQuestionTimeoutRankReq();
            batchQueryQuestionTimeoutRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1681477_1
            if (queryIdentitySmallCircleListComRespDto != null && queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList() != null && !CollectionUtil.isEmpty(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList())) {
                batchQueryQuestionTimeoutRankReq.setQuestionList(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item -> item.getEntityId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1681475_1
            }
            if (reqDto != null) {
                batchQueryQuestionTimeoutRankReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1681476_1
                batchQueryQuestionTimeoutRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681478_1
            }

            /*3-7-02批量查询问题超时排行[9006]   */
            Assert.isNull(batchQueryQuestionTimeoutRankReq.getQuestionStatus(), "D3查询个人问题超时排行列表-3-7-02批量查询问题超时排行-问题状态不能为空", false);
            Assert.isNull(batchQueryQuestionTimeoutRankReq.getSubjectLifeCycle(), "D3查询个人问题超时排行列表-3-7-02批量查询问题超时排行-主体生命周期不能为空", false);
            Assert.isNull(batchQueryQuestionTimeoutRankReq.getSpaceId(), "D3查询个人问题超时排行列表-3-7-02批量查询问题超时排行-创建于空间ID不能为空", false);
            listOmsQuestion = mOmsQuestionService.batchQueryQuestionTimeoutRank(batchQueryQuestionTimeoutRankReq)/*vcase invoke 本地 method 方法调用;*/;


            listOmsQuestion_1 = listOmsQuestion;
        }

        QueryPersonalQuestionTimeoutRankListRespDto retData = new QueryPersonalQuestionTimeoutRankListRespDto();
        retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1681491_1


        return retData;
    }

    /**
     * D3查询部门任务进度排行图表列表[9011]
     * gen by moon at 4/2/2024, 6:21:54 PM
     */
    @Trace(operationName = "D3查询部门任务进度排行图表列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryDeptTaskProgressRankingChartListRespDto queryDeptTaskProgressRankingChartList(QueryDeptTaskProgressRankingChartListReqDto reqDto) {


        List<OmsTask> listOmsTask_1 = new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1681891_1
            receptionServiceReq.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1681892_1
            receptionServiceReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1685266_1
            receptionServiceReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1681889_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681881_1
        }

        /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getDeptId(), "D3查询部门任务进度排行图表列表-M3接收入参字段-部门ID不能为空", false);
        Assert.isNull(receptionServiceReq.getUseScene(), "D3查询部门任务进度排行图表列表-M3接收入参字段-虚拟组织使用场景不能为空", false);
        Assert.isNull(receptionServiceReq.getTableTypeCode(), "D3查询部门任务进度排行图表列表-M3接收入参字段-冗余内容表类型编码不能为空", false);
        Assert.isNull(receptionServiceReq.getTaskStatus(), "D3查询部门任务进度排行图表列表-M3接收入参字段-任务进展状态不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询部门任务进度排行图表列表-M3接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D3查询部门下人员工作小圈子列表(公共) - queryDeptSubPersonnelSmallCircleListCom
        QueryDeptSubPersonnelSmallCircleListComRespDto queryDeptSubPersonnelSmallCircleListComRespDto = null;
        QueryDeptSubPersonnelSmallCircleListComReqDto queryDeptSubPersonnelSmallCircleListComReqDto = new QueryDeptSubPersonnelSmallCircleListComReqDto();
        if (reqDto != null) {
            queryDeptSubPersonnelSmallCircleListComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1681722_1
            queryDeptSubPersonnelSmallCircleListComReqDto.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1681725_1
            queryDeptSubPersonnelSmallCircleListComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1685209_1
            queryDeptSubPersonnelSmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681723_1
        }

        /*D3查询部门下人员工作小圈子列表(公共)[8991]   */
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getDeptId(), "D3查询部门任务进度排行图表列表-D3查询部门下人员工作小圈子列表(公共)-部门ID不能为空", false);
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getUseScene(), "D3查询部门任务进度排行图表列表-D3查询部门下人员工作小圈子列表(公共)-虚拟组织使用场景不能为空", false);
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getSpaceId(), "D3查询部门任务进度排行图表列表-D3查询部门下人员工作小圈子列表(公共)-创建于空间ID不能为空", false);
        queryDeptSubPersonnelSmallCircleListComRespDto = queryDeptSubPersonnelSmallCircleListCom(queryDeptSubPersonnelSmallCircleListComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤2: 3-7-01批量查询任务进度排行 - batchQueryTaskProgressRank
        List<OmsTask> listOmsTask = new ArrayList<>();
        if (queryDeptSubPersonnelSmallCircleListComRespDto != null) {
            BatchQueryTaskProgressRankReq batchQueryTaskProgressRankReq = new BatchQueryTaskProgressRankReq();
            batchQueryTaskProgressRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1681728_1
            if (queryDeptSubPersonnelSmallCircleListComRespDto != null && queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList() != null && !CollectionUtil.isEmpty(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList())) {
                batchQueryTaskProgressRankReq.setTaskDataList(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item -> item.getEntityId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1681731_1
            }
            if (reqDto != null) {
                batchQueryTaskProgressRankReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1681727_1
                batchQueryTaskProgressRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681729_1
            }

            /*3-7-01批量查询任务进度排行[8999]   */
            Assert.isNull(batchQueryTaskProgressRankReq.getTaskStatus(), "D3查询部门任务进度排行图表列表-3-7-01批量查询任务进度排行-任务进展状态不能为空", false);
            Assert.isNull(batchQueryTaskProgressRankReq.getSubjectLifeCycle(), "D3查询部门任务进度排行图表列表-3-7-01批量查询任务进度排行-主体生命周期不能为空", false);
            Assert.isNull(batchQueryTaskProgressRankReq.getSpaceId(), "D3查询部门任务进度排行图表列表-3-7-01批量查询任务进度排行-创建于空间ID不能为空", false);
            listOmsTask = mOmsTaskService.batchQueryTaskProgressRank(batchQueryTaskProgressRankReq)/*vcase invoke 本地 method 方法调用;*/;


            listOmsTask_1 = listOmsTask;
        }

        QueryDeptTaskProgressRankingChartListRespDto retData = new QueryDeptTaskProgressRankingChartListRespDto();
        retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1681904_1


        return retData;
    }

    /**
     * D3查询部门任务逾期排行列表[9012]
     * gen by moon at 4/2/2024, 6:21:56 PM
     */
    @Trace(operationName = "D3查询部门任务逾期排行列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryDeptTaskExpiedRankingListRespDto queryDeptTaskExpiedRankingList(QueryDeptTaskExpiedRankingListReqDto reqDto) {


        List<OmsTask> listOmsTask_1 = new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1682089_1
            receptionServiceReq.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1682090_1
            receptionServiceReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1685278_1
            receptionServiceReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1682094_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682092_1
        }

        /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getDeptId(), "D3查询部门任务逾期排行列表-M3接收入参字段-部门ID不能为空", false);
        Assert.isNull(receptionServiceReq.getUseScene(), "D3查询部门任务逾期排行列表-M3接收入参字段-虚拟组织使用场景不能为空", false);
        Assert.isNull(receptionServiceReq.getTableTypeCode(), "D3查询部门任务逾期排行列表-M3接收入参字段-冗余内容表类型编码不能为空", false);
        Assert.isNull(receptionServiceReq.getStateCode(), "D3查询部门任务逾期排行列表-M3接收入参字段-内容冗余状态不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询部门任务逾期排行列表-M3接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D3查询部门下人员工作小圈子列表(公共) - queryDeptSubPersonnelSmallCircleListCom
        QueryDeptSubPersonnelSmallCircleListComRespDto queryDeptSubPersonnelSmallCircleListComRespDto = null;
        QueryDeptSubPersonnelSmallCircleListComReqDto queryDeptSubPersonnelSmallCircleListComReqDto = new QueryDeptSubPersonnelSmallCircleListComReqDto();
        if (reqDto != null) {
            queryDeptSubPersonnelSmallCircleListComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1682079_1
            queryDeptSubPersonnelSmallCircleListComReqDto.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1682082_1
            queryDeptSubPersonnelSmallCircleListComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1685210_1
            queryDeptSubPersonnelSmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682080_1
        }

        /*D3查询部门下人员工作小圈子列表(公共)[8991]   */
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getDeptId(), "D3查询部门任务逾期排行列表-D3查询部门下人员工作小圈子列表(公共)-部门ID不能为空", false);
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getUseScene(), "D3查询部门任务逾期排行列表-D3查询部门下人员工作小圈子列表(公共)-虚拟组织使用场景不能为空", false);
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getTableTypeCode(), "D3查询部门任务逾期排行列表-D3查询部门下人员工作小圈子列表(公共)-冗余内容表类型编码不能为空", false);
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getSpaceId(), "D3查询部门任务逾期排行列表-D3查询部门下人员工作小圈子列表(公共)-创建于空间ID不能为空", false);
        queryDeptSubPersonnelSmallCircleListComRespDto = queryDeptSubPersonnelSmallCircleListCom(queryDeptSubPersonnelSmallCircleListComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤2: 3-7-01批量查询任务逾期排行 - batchQueryTaskExpiedRank
        List<OmsTask> listOmsTask = new ArrayList<>();
        if (queryDeptSubPersonnelSmallCircleListComRespDto != null) {
            BatchQueryTaskExpiedRankReq batchQueryTaskExpiedRankReq = new BatchQueryTaskExpiedRankReq();
            batchQueryTaskExpiedRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682087_1
            if (queryDeptSubPersonnelSmallCircleListComRespDto != null && queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList() != null && !CollectionUtil.isEmpty(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList())) {
                batchQueryTaskExpiedRankReq.setTaskDataList(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item -> item.getEntityId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1682084_1
            }
            if (reqDto != null) {
                batchQueryTaskExpiedRankReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1682086_1
                batchQueryTaskExpiedRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682088_1
            }

            /*3-7-01批量查询任务逾期排行[9002]   */
            Assert.isNull(batchQueryTaskExpiedRankReq.getStateCode(), "D3查询部门任务逾期排行列表-3-7-01批量查询任务逾期排行-内容冗余状态不能为空", false);
            Assert.isNull(batchQueryTaskExpiedRankReq.getSubjectLifeCycle(), "D3查询部门任务逾期排行列表-3-7-01批量查询任务逾期排行-主体生命周期不能为空", false);
            Assert.isNull(batchQueryTaskExpiedRankReq.getSpaceId(), "D3查询部门任务逾期排行列表-3-7-01批量查询任务逾期排行-创建于空间ID不能为空", false);
            listOmsTask = mOmsTaskService.batchQueryTaskExpiedRank(batchQueryTaskExpiedRankReq)/*vcase invoke 本地 method 方法调用;*/;


            listOmsTask_1 = listOmsTask;
        }

        QueryDeptTaskExpiedRankingListRespDto retData = new QueryDeptTaskExpiedRankingListRespDto();
        retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1682100_1


        return retData;
    }

    /**
     * D3查询部门问题解决天数排行图表列表[9013]
     * gen by moon at 4/2/2024, 11:50:56 PM
     */
    @Trace(operationName = "D3查询部门问题解决天数排行图表列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryDeptQuestionSolvesRankingChartListRespDto queryDeptQuestionSolvesRankingChartList(QueryDeptQuestionSolvesRankingChartListReqDto reqDto) {


        List<OmsQuestion> listOmsQuestion_1 = new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1682512_1
            receptionServiceReq.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1682527_1
            receptionServiceReq.setOwnTableTypeCode(reqDto.getOwnTableTypeCode());//SimpleFieldAssign//sourceId:1682529_1
            receptionServiceReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1682552_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682528_1
        }

        /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getDeptId(), "D3查询部门问题解决天数排行图表列表-M3接收入参字段-部门ID不能为空", false);
        Assert.isNull(receptionServiceReq.getUseScene(), "D3查询部门问题解决天数排行图表列表-M3接收入参字段-虚拟组织使用场景不能为空", false);
        Assert.isNull(receptionServiceReq.getOwnTableTypeCode(), "D3查询部门问题解决天数排行图表列表-M3接收入参字段-归属内容表类型编码不能为空", false);
        Assert.isNull(receptionServiceReq.getQuestionStatus(), "D3查询部门问题解决天数排行图表列表-M3接收入参字段-问题状态不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询部门问题解决天数排行图表列表-M3接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D3查询部门下人员工作小圈子列表(公共) - queryDeptSubPersonnelSmallCircleListCom
        QueryDeptSubPersonnelSmallCircleListComRespDto queryDeptSubPersonnelSmallCircleListComRespDto = null;
        QueryDeptSubPersonnelSmallCircleListComReqDto queryDeptSubPersonnelSmallCircleListComReqDto = new QueryDeptSubPersonnelSmallCircleListComReqDto();
        if (reqDto != null) {
            queryDeptSubPersonnelSmallCircleListComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1682502_1
            queryDeptSubPersonnelSmallCircleListComReqDto.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1682505_1
            queryDeptSubPersonnelSmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682503_1
        }

        /*D3查询部门下人员工作小圈子列表(公共)[8991]   */
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getDeptId(), "D3查询部门问题解决天数排行图表列表-D3查询部门下人员工作小圈子列表(公共)-部门ID不能为空", false);
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getUseScene(), "D3查询部门问题解决天数排行图表列表-D3查询部门下人员工作小圈子列表(公共)-虚拟组织使用场景不能为空", false);
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getTableTypeCode(), "D3查询部门问题解决天数排行图表列表-D3查询部门下人员工作小圈子列表(公共)-冗余内容表类型编码不能为空", false);
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getSpaceId(), "D3查询部门问题解决天数排行图表列表-D3查询部门下人员工作小圈子列表(公共)-创建于空间ID不能为空", false);
        queryDeptSubPersonnelSmallCircleListComRespDto = queryDeptSubPersonnelSmallCircleListCom(queryDeptSubPersonnelSmallCircleListComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤2: 3-7-02批量查询问题解决天数排行 - batchQueryQuestionSolvesRank
        List<OmsQuestion> listOmsQuestion = new ArrayList<>();
        if (queryDeptSubPersonnelSmallCircleListComRespDto != null) {
            BatchQueryQuestionSolvesRankReq batchQueryQuestionSolvesRankReq = new BatchQueryQuestionSolvesRankReq();
            batchQueryQuestionSolvesRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682509_1
            if (queryDeptSubPersonnelSmallCircleListComRespDto != null && queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList() != null && !CollectionUtil.isEmpty(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList())) {
                batchQueryQuestionSolvesRankReq.setQuestionList(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item -> item.getEntityId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1682507_1
            }
            if (reqDto != null) {
                batchQueryQuestionSolvesRankReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1682508_1
                batchQueryQuestionSolvesRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682510_1
            }

            /*3-7-02批量查询问题解决天数排行[9004]   */
            Assert.isNull(batchQueryQuestionSolvesRankReq.getQuestionStatus(), "D3查询部门问题解决天数排行图表列表-3-7-02批量查询问题解决天数排行-问题状态不能为空", false);
            Assert.isNull(batchQueryQuestionSolvesRankReq.getSubjectLifeCycle(), "D3查询部门问题解决天数排行图表列表-3-7-02批量查询问题解决天数排行-主体生命周期不能为空", false);
            Assert.isNull(batchQueryQuestionSolvesRankReq.getSpaceId(), "D3查询部门问题解决天数排行图表列表-3-7-02批量查询问题解决天数排行-创建于空间ID不能为空", false);
            listOmsQuestion = mOmsQuestionService.batchQueryQuestionSolvesRank(batchQueryQuestionSolvesRankReq)/*vcase invoke 本地 method 方法调用;*/;


            listOmsQuestion_1 = listOmsQuestion;
        }

        QueryDeptQuestionSolvesRankingChartListRespDto retData = new QueryDeptQuestionSolvesRankingChartListRespDto();
        retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1682559_1


        return retData;
    }

    /**
     * D3查询部门问题超时排行列表[9014]
     * gen by moon at 4/2/2024, 6:22:00 PM
     */
    @Trace(operationName = "D3查询部门问题超时排行列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryDeptQuestionOvertimeRankingListRespDto queryDeptQuestionOvertimeRankingList(QueryDeptQuestionOvertimeRankingListReqDto reqDto) {


        List<OmsQuestion> listOmsQuestion_1 = new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1682572_1
            receptionServiceReq.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1682586_1
            receptionServiceReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1685281_1
            receptionServiceReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1682574_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682573_1
        }

        /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getDeptId(), "D3查询部门问题超时排行列表-M3接收入参字段-部门ID不能为空", false);
        Assert.isNull(receptionServiceReq.getUseScene(), "D3查询部门问题超时排行列表-M3接收入参字段-虚拟组织使用场景不能为空", false);
        Assert.isNull(receptionServiceReq.getTableTypeCode(), "D3查询部门问题超时排行列表-M3接收入参字段-冗余内容表类型编码不能为空", false);
        Assert.isNull(receptionServiceReq.getQuestionStatus(), "D3查询部门问题超时排行列表-M3接收入参字段-问题状态不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询部门问题超时排行列表-M3接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D3查询部门下人员工作小圈子列表(公共) - queryDeptSubPersonnelSmallCircleListCom
        QueryDeptSubPersonnelSmallCircleListComRespDto queryDeptSubPersonnelSmallCircleListComRespDto = null;
        QueryDeptSubPersonnelSmallCircleListComReqDto queryDeptSubPersonnelSmallCircleListComReqDto = new QueryDeptSubPersonnelSmallCircleListComReqDto();
        if (reqDto != null) {
            queryDeptSubPersonnelSmallCircleListComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1682575_1
            queryDeptSubPersonnelSmallCircleListComReqDto.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1682578_1
            queryDeptSubPersonnelSmallCircleListComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1685211_1
            queryDeptSubPersonnelSmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682576_1
        }

        /*D3查询部门下人员工作小圈子列表(公共)[8991]   */
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getDeptId(), "D3查询部门问题超时排行列表-D3查询部门下人员工作小圈子列表(公共)-部门ID不能为空", false);
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getUseScene(), "D3查询部门问题超时排行列表-D3查询部门下人员工作小圈子列表(公共)-虚拟组织使用场景不能为空", false);
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getTableTypeCode(), "D3查询部门问题超时排行列表-D3查询部门下人员工作小圈子列表(公共)-冗余内容表类型编码不能为空", false);
        Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getSpaceId(), "D3查询部门问题超时排行列表-D3查询部门下人员工作小圈子列表(公共)-创建于空间ID不能为空", false);
        queryDeptSubPersonnelSmallCircleListComRespDto = queryDeptSubPersonnelSmallCircleListCom(queryDeptSubPersonnelSmallCircleListComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤2: 3-7-02批量查询问题超时排行 - batchQueryQuestionTimeoutRank
        List<OmsQuestion> listOmsQuestion = new ArrayList<>();
        if (queryDeptSubPersonnelSmallCircleListComRespDto != null) {
            BatchQueryQuestionTimeoutRankReq batchQueryQuestionTimeoutRankReq = new BatchQueryQuestionTimeoutRankReq();
            batchQueryQuestionTimeoutRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682582_1
            if (queryDeptSubPersonnelSmallCircleListComRespDto != null && queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList() != null && !CollectionUtil.isEmpty(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList())) {
                batchQueryQuestionTimeoutRankReq.setQuestionList(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item -> item.getEntityId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1682580_1
            }
            if (reqDto != null) {
                batchQueryQuestionTimeoutRankReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1682581_1
                batchQueryQuestionTimeoutRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682583_1
            }

            /*3-7-02批量查询问题超时排行[9006]   */
            Assert.isNull(batchQueryQuestionTimeoutRankReq.getQuestionStatus(), "D3查询部门问题超时排行列表-3-7-02批量查询问题超时排行-问题状态不能为空", false);
            Assert.isNull(batchQueryQuestionTimeoutRankReq.getSubjectLifeCycle(), "D3查询部门问题超时排行列表-3-7-02批量查询问题超时排行-主体生命周期不能为空", false);
            Assert.isNull(batchQueryQuestionTimeoutRankReq.getSpaceId(), "D3查询部门问题超时排行列表-3-7-02批量查询问题超时排行-创建于空间ID不能为空", false);
            listOmsQuestion = mOmsQuestionService.batchQueryQuestionTimeoutRank(batchQueryQuestionTimeoutRankReq)/*vcase invoke 本地 method 方法调用;*/;


            listOmsQuestion_1 = listOmsQuestion;
        }

        QueryDeptQuestionOvertimeRankingListRespDto retData = new QueryDeptQuestionOvertimeRankingListRespDto();
        retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1682593_1


        return retData;
    }

    /**
     * D3查询下属工作任务进度排行列表[9021]
     * gen by moon at 4/1/2024, 1:58:41 AM
     */
    @Trace(operationName = "D3查询下属工作任务进度排行列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QuerySubordinateWorkTaskProgressRankListRespDto querySubordinateWorkTaskProgressRankList(QuerySubordinateWorkTaskProgressRankListReqDto reqDto) {


        List<OmsTask> listOmsTask_1 = new ArrayList<>();
//步骤0: D3查询我身份所在小圈子列表(公共) - queryIdentitySmallCircleListCom
        QueryIdentitySmallCircleListComRespDto queryIdentitySmallCircleListComRespDto = null;
        QueryIdentitySmallCircleListComReqDto queryIdentitySmallCircleListComReqDto = new QueryIdentitySmallCircleListComReqDto();
        queryIdentitySmallCircleListComReqDto.setTableTypeCode("OMS_TASK");//sourceId:1682125_1
        queryIdentitySmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1682120_1
        queryIdentitySmallCircleListComReqDto.setIsDisplay("TRUE");//sourceId:1682122_1
        queryIdentitySmallCircleListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682123_1
        if (reqDto != null) {
            queryIdentitySmallCircleListComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1682117_1
            queryIdentitySmallCircleListComReqDto.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1682119_1
            queryIdentitySmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682129_1
        }

        /*D3查入参身份人员作为主管的工作任务列表[8803]   */
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getOriginalRoleMemberId(), "D3查询下属工作任务进度排行列表-D3查入参身份人员作为主管的工作任务列表-身份人员ID不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getRoleCode(), "D3查询下属工作任务进度排行列表-D3查入参身份人员作为主管的工作任务列表-角色标识不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getTableTypeCode(), "D3查询下属工作任务进度排行列表-D3查入参身份人员作为主管的工作任务列表-冗余内容表类型编码不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getUseScene(), "D3查询下属工作任务进度排行列表-D3查入参身份人员作为主管的工作任务列表-虚拟组织使用场景不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsDisplay(), "D3查询下属工作任务进度排行列表-D3查入参身份人员作为主管的工作任务列表-是否外部展示不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getSubjectLifeCycle(), "D3查询下属工作任务进度排行列表-D3查入参身份人员作为主管的工作任务列表-主体生命周期不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getSpaceId(), "D3查询下属工作任务进度排行列表-D3查入参身份人员作为主管的工作任务列表-创建于空间ID不能为空", false);
        queryIdentitySmallCircleListComRespDto = smallCircleCommonService.queryIdentitySmallCircleListCom(queryIdentitySmallCircleListComReqDto)/*vcase invoke isSameApp*/;


//步骤1: 3-7-01批量查询任务进度排行 - batchQueryTaskProgressRank
        List<OmsTask> listOmsTask = new ArrayList<>();
        if (queryIdentitySmallCircleListComRespDto != null) {
            BatchQueryTaskProgressRankReq batchQueryTaskProgressRankReq = new BatchQueryTaskProgressRankReq();
            batchQueryTaskProgressRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682148_1
            if (queryIdentitySmallCircleListComRespDto != null && queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList() != null && !CollectionUtil.isEmpty(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList())) {
                batchQueryTaskProgressRankReq.setTaskDataList(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item -> item.getEntityId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1682151_1
            }
            if (reqDto != null) {
                batchQueryTaskProgressRankReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1682147_1
                batchQueryTaskProgressRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682149_1
            }

            /*3-7-01批量查询任务进度排行[8999]   */
            Assert.isNull(batchQueryTaskProgressRankReq.getTaskStatus(), "D3查询下属工作任务进度排行列表-3-7-01批量查询任务进度排行-任务进展状态不能为空", false);
            Assert.isNull(batchQueryTaskProgressRankReq.getSubjectLifeCycle(), "D3查询下属工作任务进度排行列表-3-7-01批量查询任务进度排行-主体生命周期不能为空", false);
            Assert.isNull(batchQueryTaskProgressRankReq.getSpaceId(), "D3查询下属工作任务进度排行列表-3-7-01批量查询任务进度排行-创建于空间ID不能为空", false);
            listOmsTask = mOmsTaskService.batchQueryTaskProgressRank(batchQueryTaskProgressRankReq)/*vcase invoke 本地 method 方法调用;*/;


            listOmsTask_1 = listOmsTask;
        }

        QuerySubordinateWorkTaskProgressRankListRespDto retData = new QuerySubordinateWorkTaskProgressRankListRespDto();
        retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1682156_1


        return retData;
    }

    /**
     * D3查询下属工作任务逾期排行列表[9022]
     * gen by moon at 4/1/2024, 1:58:54 AM
     */
    @Trace(operationName = "D3查询下属工作任务逾期排行列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QuerySubordinateWorkTaskOverdueRankListRespDto querySubordinateWorkTaskOverdueRankList(QuerySubordinateWorkTaskOverdueRankListReqDto reqDto) {


        List<OmsTask> listOmsTask_1 = new ArrayList<>();
//步骤0: D3查询我身份所在小圈子列表(公共) - queryIdentitySmallCircleListCom
        QueryIdentitySmallCircleListComRespDto queryIdentitySmallCircleListComRespDto = null;
        QueryIdentitySmallCircleListComReqDto queryIdentitySmallCircleListComReqDto = new QueryIdentitySmallCircleListComReqDto();
        queryIdentitySmallCircleListComReqDto.setTableTypeCode("OMS_TASK");//sourceId:1682462_1
        queryIdentitySmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1682457_1
        queryIdentitySmallCircleListComReqDto.setIsDisplay("TRUE");//sourceId:1682459_1
        queryIdentitySmallCircleListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682460_1
        if (reqDto != null) {
            queryIdentitySmallCircleListComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1682454_1
            queryIdentitySmallCircleListComReqDto.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1682456_1
            queryIdentitySmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682466_1
        }

        /*D3查入参身份人员作为主管的工作任务列表[8803]   */
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getOriginalRoleMemberId(), "D3查询下属工作任务逾期排行列表-D3查入参身份人员作为主管的工作任务列表-身份人员ID不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getRoleCode(), "D3查询下属工作任务逾期排行列表-D3查入参身份人员作为主管的工作任务列表-角色标识不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getTableTypeCode(), "D3查询下属工作任务逾期排行列表-D3查入参身份人员作为主管的工作任务列表-冗余内容表类型编码不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getUseScene(), "D3查询下属工作任务逾期排行列表-D3查入参身份人员作为主管的工作任务列表-虚拟组织使用场景不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsDisplay(), "D3查询下属工作任务逾期排行列表-D3查入参身份人员作为主管的工作任务列表-是否外部展示不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getSubjectLifeCycle(), "D3查询下属工作任务逾期排行列表-D3查入参身份人员作为主管的工作任务列表-主体生命周期不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getSpaceId(), "D3查询下属工作任务逾期排行列表-D3查入参身份人员作为主管的工作任务列表-创建于空间ID不能为空", false);
        queryIdentitySmallCircleListComRespDto = smallCircleCommonService.queryIdentitySmallCircleListCom(queryIdentitySmallCircleListComReqDto)/*vcase invoke isSameApp*/;


//步骤1: 3-7-01批量查询任务逾期排行 - batchQueryTaskExpiedRank
        List<OmsTask> listOmsTask = new ArrayList<>();
        if (queryIdentitySmallCircleListComRespDto != null) {
            BatchQueryTaskExpiedRankReq batchQueryTaskExpiedRankReq = new BatchQueryTaskExpiedRankReq();
            batchQueryTaskExpiedRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682486_1
            if (queryIdentitySmallCircleListComRespDto != null && queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList() != null && !CollectionUtil.isEmpty(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList())) {
                batchQueryTaskExpiedRankReq.setTaskDataList(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item -> item.getEntityId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1682483_1
            }
            if (reqDto != null) {
                batchQueryTaskExpiedRankReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1682485_1
                batchQueryTaskExpiedRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682487_1
            }

            /*3-7-01批量查询任务逾期排行[9002]   */
            Assert.isNull(batchQueryTaskExpiedRankReq.getStateCode(), "D3查询下属工作任务逾期排行列表-3-7-01批量查询任务逾期排行-内容冗余状态不能为空", false);
            Assert.isNull(batchQueryTaskExpiedRankReq.getSubjectLifeCycle(), "D3查询下属工作任务逾期排行列表-3-7-01批量查询任务逾期排行-主体生命周期不能为空", false);
            Assert.isNull(batchQueryTaskExpiedRankReq.getSpaceId(), "D3查询下属工作任务逾期排行列表-3-7-01批量查询任务逾期排行-创建于空间ID不能为空", false);
            listOmsTask = mOmsTaskService.batchQueryTaskExpiedRank(batchQueryTaskExpiedRankReq)/*vcase invoke 本地 method 方法调用;*/;


            listOmsTask_1 = listOmsTask;
        }

        QuerySubordinateWorkTaskOverdueRankListRespDto retData = new QuerySubordinateWorkTaskOverdueRankListRespDto();
        retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1682491_1


        return retData;
    }

    /**
     * D3查询主管下属问题解决天数排行列表[9023]
     * gen by moon at 4/1/2024, 2:32:12 AM
     */
    @Trace(operationName = "D3查询主管下属问题解决天数排行列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryChargeSubQuestionSolveRankListRespDto queryChargeSubQuestionSolveRankList(QueryChargeSubQuestionSolveRankListReqDto reqDto) {


        List<OmsQuestion> listOmsQuestion_1 = new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:1683037_1
            receptionServiceReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1683039_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1683038_1
        }

        /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getDirectorInductionRecordId(), "D3查询主管下属问题解决天数排行列表-M3接收入参字段-可选主管就职记录ID不能为空", false);
        Assert.isNull(receptionServiceReq.getQuestionStatus(), "D3查询主管下属问题解决天数排行列表-M3接收入参字段-问题状态不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询主管下属问题解决天数排行列表-M3接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D3查询主管我下属小圈子列表(公共) - queryChargeSubordinateSmallCircleListCom
        QueryChargeSubordinateSmallCircleListComRespDto queryChargeSubordinateSmallCircleListComRespDto = null;
        QueryChargeSubordinateSmallCircleListComReqDto queryChargeSubordinateSmallCircleListComReqDto = new QueryChargeSubordinateSmallCircleListComReqDto();
        queryChargeSubordinateSmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1682813_1
        queryChargeSubordinateSmallCircleListComReqDto.setIsPersonCharge("TRUE");//sourceId:1682814_1
        queryChargeSubordinateSmallCircleListComReqDto.setTableTypeCode("OMS_QUESTION");//sourceId:1682815_1
        if (reqDto != null) {
            queryChargeSubordinateSmallCircleListComReqDto.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:1682812_1
            queryChargeSubordinateSmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682817_1
        }

        /*D3查询主管我下属小圈子列表(公共)[9034]   */
        Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getDirectorInductionRecordId(), "D3查询主管下属问题解决天数排行列表-D3查询主管我下属小圈子列表(公共)-可选主管就职记录ID不能为空", false);
        Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getUseScene(), "D3查询主管下属问题解决天数排行列表-D3查询主管我下属小圈子列表(公共)-虚拟组织使用场景不能为空", false);
        Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getIsPersonCharge(), "D3查询主管下属问题解决天数排行列表-D3查询主管我下属小圈子列表(公共)-是否负责人不能为空", false);
        Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getTableTypeCode(), "D3查询主管下属问题解决天数排行列表-D3查询主管我下属小圈子列表(公共)-冗余内容表类型编码不能为空", false);
        Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getSpaceId(), "D3查询主管下属问题解决天数排行列表-D3查询主管我下属小圈子列表(公共)-创建于空间ID不能为空", false);
        queryChargeSubordinateSmallCircleListComRespDto = smallCircleCommonService.queryChargeSubordinateSmallCircleListCom(queryChargeSubordinateSmallCircleListComReqDto)/*vcase invoke isSameApp*/;


//步骤2: 3-7-02批量查询问题解决天数排行 - batchQueryQuestionSolvesRank
        List<OmsQuestion> listOmsQuestion = new ArrayList<>();
        if (queryChargeSubordinateSmallCircleListComRespDto != null) {
            BatchQueryQuestionSolvesRankReq batchQueryQuestionSolvesRankReq = new BatchQueryQuestionSolvesRankReq();
            batchQueryQuestionSolvesRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682821_1
            if (queryChargeSubordinateSmallCircleListComRespDto != null && queryChargeSubordinateSmallCircleListComRespDto.getVirtualOrgMemberList() != null && !CollectionUtil.isEmpty(queryChargeSubordinateSmallCircleListComRespDto.getVirtualOrgMemberList())) {
                batchQueryQuestionSolvesRankReq.setQuestionList(queryChargeSubordinateSmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item -> item.getEntityId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1682819_1
            }
            if (reqDto != null) {
                batchQueryQuestionSolvesRankReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1682820_1
                batchQueryQuestionSolvesRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682822_1
            }

            /*3-7-02批量查询问题解决天数排行[9004]   */
            Assert.isNull(batchQueryQuestionSolvesRankReq.getQuestionStatus(), "D3查询主管下属问题解决天数排行列表-3-7-02批量查询问题解决天数排行-问题状态不能为空", false);
            Assert.isNull(batchQueryQuestionSolvesRankReq.getSubjectLifeCycle(), "D3查询主管下属问题解决天数排行列表-3-7-02批量查询问题解决天数排行-主体生命周期不能为空", false);
            Assert.isNull(batchQueryQuestionSolvesRankReq.getSpaceId(), "D3查询主管下属问题解决天数排行列表-3-7-02批量查询问题解决天数排行-创建于空间ID不能为空", false);
            listOmsQuestion = mOmsQuestionService.batchQueryQuestionSolvesRank(batchQueryQuestionSolvesRankReq)/*vcase invoke 本地 method 方法调用;*/;


            listOmsQuestion_1 = listOmsQuestion;
        }

        QueryChargeSubQuestionSolveRankListRespDto retData = new QueryChargeSubQuestionSolveRankListRespDto();
        retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1683046_1


        return retData;
    }

    /**
     * D3批量查询工作任务(公共)[8982]
     * gen by moon at 4/1/2024, 2:00:18 AM
     */
    @Trace(operationName = "D3批量查询工作任务(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchQueryWorkTaskDataComRespDto batchQueryWorkTaskDataCom(BatchQueryWorkTaskDataComReqDto reqDto) {


        List<OmsTask> listOmsTask_1 = new ArrayList<>();
//步骤0: 3-7-01批量查任务列表 - batchQueryTask
        List<OmsTask> listOmsTask = new ArrayList<>();
        BatchQueryTaskReq batchQueryTaskReq = new BatchQueryTaskReq();
        if (reqDto != null) {
            batchQueryTaskReq.setReportingTaskList(reqDto.getWorkTaskList());//list-field-assign//sourceId:1678086_1
            batchQueryTaskReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1678102_1
            batchQueryTaskReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1678088_1
            batchQueryTaskReq.setBizSceneCode(reqDto.getBizSceneCode());//SimpleFieldAssign//sourceId:1678098_1
            batchQueryTaskReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1678095_1
            batchQueryTaskReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1678101_1
            batchQueryTaskReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1678099_1
        }

        /*3-7-01批量查任务列表[2566]   */
        Assert.isNull(batchQueryTaskReq.getSpaceId(), "D3批量查询工作任务(公共)-3-7-01批量查任务列表-创建于空间ID不能为空", false);
        listOmsTask = mOmsTaskService.batchQueryTask(batchQueryTaskReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsTask_1 = listOmsTask;

        BatchQueryWorkTaskDataComRespDto retData = new BatchQueryWorkTaskDataComRespDto();
        retData.setWorkContentList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, WorkContentDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1678113_1


        return retData;
    }

    /**
     * D3查询工作任务周期导航列表[8992]
     * gen by moon at 4/1/2024, 2:00:59 AM
     */
    @Trace(operationName = "D3查询工作任务周期导航列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryWorkTaskCycleNavListRespDto queryWorkTaskCycleNavList(QueryWorkTaskCycleNavListReqDto reqDto) {


        ImplementEightReceivingFieldRespDto receptionServiceRes_3 = null;
//virtualUsage M3获取系统当前时间  65812
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        receptionServiceReq.setComTimeField(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1680078_1_65812
        if (reqDto != null) {
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679602_1_65812
        }

        /*M3获取系统当前时间[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询工作任务周期导航列表-M3获取系统当前时间-创建于空间ID不能为空", false);
        Assert.isNull(receptionServiceReq.getComTimeField(), "D3查询工作任务周期导航列表-M3获取系统当前时间-通用时间字段不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//virtualUsage D2查询工作任务周期配置(公共)  65810
        QueryWorkTaskCycleConfDetailComRespDto queryWorkTaskCycleConfDetailComRespDto = null;
        QueryWorkTaskCycleConfDetailComReqDto queryWorkTaskCycleConfDetailComReqDto = new QueryWorkTaskCycleConfDetailComReqDto();
        if (reqDto != null) {
            queryWorkTaskCycleConfDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679435_1_65810
        }

        /*D2查询工作任务周期配置(公共)[8984]   */
        Assert.isNull(queryWorkTaskCycleConfDetailComReqDto.getSpaceId(), "D3查询工作任务周期导航列表-D2查询工作任务周期配置(公共)-创建于空间ID不能为空", false);
        queryWorkTaskCycleConfDetailComRespDto = fwCompDashboardWorkTaskClient.queryWorkTaskCycleConfDetailCom(queryWorkTaskCycleConfDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D2工作结束时间与系统当前时间比较（用于判断是否结束）  65813
        CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
        if (queryWorkTaskCycleConfDetailComRespDto != null) {
            CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto = new CheckTimeScopeSearchComReqDto();
            if (receptionServiceRes != null) {
                checkTimeScopeSearchComReqDto.setCurrentTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1680081_1_65813
            }
            if (queryWorkTaskCycleConfDetailComRespDto != null) {
                checkTimeScopeSearchComReqDto.setCompareTime(queryWorkTaskCycleConfDetailComRespDto.getWorkCycleEndTime());//SimpleFieldAssign//sourceId:1680083_1_65813
            }

            /*D2工作结束时间与系统当前时间比较（用于判断是否结束）[3297]   */
            Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(), "D3查询工作任务周期导航列表-D2工作结束时间与系统当前时间比较（用于判断是否结束）-当前时间不能为空", false);
            Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(), "D3查询工作任务周期导航列表-D2工作结束时间与系统当前时间比较（用于判断是否结束）-比较时间不能为空", false);
            checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        if ((checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER") || checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT"))) {
            //if((D2工作结束时间与系统当前时间比较（用于判断是否结束）.时间比较结果 等于 之后（大于） or D2工作结束时间与系统当前时间比较（用于判断是否结束）.时间比较结果 等于 当前（等于）))  65814

            AnalysisTenementCycleComRespDto analysisTenementCycleComRespDto = null;
            if (queryWorkTaskCycleConfDetailComRespDto != null) {
                AnalysisTenementCycleComReqDto analysisTenementCycleComReqDto = new AnalysisTenementCycleComReqDto();
                if (queryWorkTaskCycleConfDetailComRespDto != null) {
                    analysisTenementCycleComReqDto.setIsTenementCycle(queryWorkTaskCycleConfDetailComRespDto.getIsTenementCycle());//SimpleFieldAssign//sourceId:1679593_1_65815
                }
                if (reqDto != null) {
                    analysisTenementCycleComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679596_1_65815
                }

                /*D3分析租户周期(公共)[8903]   */
                Assert.isNull(analysisTenementCycleComReqDto.getIsTenementCycle(), "D3查询工作任务周期导航列表-D3分析租户周期(公共)-是否租户周期不能为空", false);
                Assert.isNull(analysisTenementCycleComReqDto.getSpaceId(), "D3查询工作任务周期导航列表-D3分析租户周期(公共)-创建于空间ID不能为空", false);
                analysisTenementCycleComRespDto = cycleTypeService.analysisTenementCycleCom(analysisTenementCycleComReqDto)/*vcase invoke isSameApp*/;


            }
            List<OmsCycle> listOmsCycle = new ArrayList<>();
            if (queryWorkTaskCycleConfDetailComRespDto != null && analysisTenementCycleComRespDto != null) {
                QueryCycleByEqualGreateAndLessGreateListReq queryCycleByEqualGreateAndLessGreateListReq = new QueryCycleByEqualGreateAndLessGreateListReq();
                queryCycleByEqualGreateAndLessGreateListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1680114_1_65816
                if (queryWorkTaskCycleConfDetailComRespDto != null) {
                    queryCycleByEqualGreateAndLessGreateListReq.setCycleStartTime(queryWorkTaskCycleConfDetailComRespDto.getWorkCycleStartTime());//SimpleFieldAssign//sourceId:1680110_1_65816
                    queryCycleByEqualGreateAndLessGreateListReq.setCycleTypeCode(queryWorkTaskCycleConfDetailComRespDto.getWorkCycleTypeCode());//SimpleFieldAssign//sourceId:1680112_1_65816
                }
                if (receptionServiceRes != null) {
                    queryCycleByEqualGreateAndLessGreateListReq.setCycleEndTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1680111_1_65816
                }
                if (analysisTenementCycleComRespDto != null) {
                    queryCycleByEqualGreateAndLessGreateListReq.setPlatformData(analysisTenementCycleComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:1680113_1_65816
                    queryCycleByEqualGreateAndLessGreateListReq.setSpaceId(analysisTenementCycleComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1680115_1_65816
                }

                /*3-4-04查询周期（开始大于等于结束小于等于）列表[8993]   */
                Assert.isNull(queryCycleByEqualGreateAndLessGreateListReq.getCycleStartTime(), "D3查询工作任务周期导航列表-3-4-04查询周期（开始大于等于结束小于等于）列表-周期开始时间不能为空", false);
                Assert.isNull(queryCycleByEqualGreateAndLessGreateListReq.getCycleTypeCode(), "D3查询工作任务周期导航列表-3-4-04查询周期（开始大于等于结束小于等于）列表-周期类型标识不能为空", false);
                Assert.isNull(queryCycleByEqualGreateAndLessGreateListReq.getSubjectLifeCycle(), "D3查询工作任务周期导航列表-3-4-04查询周期（开始大于等于结束小于等于）列表-主体生命周期不能为空", false);
                listOmsCycle = mOmsCycleService.queryCycleByEqualGreateAndLessGreateList(queryCycleByEqualGreateAndLessGreateListReq)/*vcase invoke 本地 method 方法调用;*/;


            }
//ModelCode: receptionService
            ImplementEightReceivingFieldRespDto receptionServiceRes_2 = null;
            if (listOmsCycle != null && !CollectionUtil.isEmpty(listOmsCycle) && listOmsCycle.size() > 0) {
                ImplementEightReceivingFieldReqDto receptionServiceReq_1 = new ImplementEightReceivingFieldReqDto();
                if (listOmsCycle != null && !CollectionUtil.isEmpty(listOmsCycle) && listOmsCycle != null && !CollectionUtil.isEmpty(listOmsCycle)) {
                    receptionServiceReq_1.setCycleList(listOmsCycle.stream().map(item -> BeanUtil.toBean(item, CycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1680324_1_65817
                }

                /*M3接收工作任务周期导航出参[8691]  用于特殊方法接收上游入参。 */

                receptionServiceRes_2 = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq_1);


                receptionServiceRes_3 = receptionServiceRes_2;
            }
        }
        QueryWorkTaskCycleNavListRespDto retData = new QueryWorkTaskCycleNavListRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setCycleList(receptionServiceRes_3.getCycleList().stream().map(item -> BeanUtil.toBean(item, CycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1680327_1
        }


        return retData;
    }

    /**
     * D3查询个人工作任务进度排行列表[9000]
     * gen by moon at 4/1/2024, 2:01:12 AM
     */
    @Trace(operationName = "D3查询个人工作任务进度排行列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryPersonalWorkTaskProgressRankListRespDto queryPersonalWorkTaskProgressRankList(QueryPersonalWorkTaskProgressRankListReqDto reqDto) {


        List<OmsTask> listOmsTask_1 = new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1680951_1
            receptionServiceReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1681037_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1680948_1
        }

        /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getTaskStatus(), "D3查询个人工作任务进度排行列表-M3接收入参字段-任务进展状态不能为空", false);
        Assert.isNull(receptionServiceReq.getOriginalRoleMemberId(), "D3查询个人工作任务进度排行列表-M3接收入参字段-身份人员ID不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询个人工作任务进度排行列表-M3接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D3查询我身份所在小圈子列表(公共) - queryIdentitySmallCircleListCom
        QueryIdentitySmallCircleListComRespDto queryIdentitySmallCircleListComRespDto = null;
        QueryIdentitySmallCircleListComReqDto queryIdentitySmallCircleListComReqDto = new QueryIdentitySmallCircleListComReqDto();
        queryIdentitySmallCircleListComReqDto.setIsPersonCharge("TRUE");//sourceId:1680847_1
        queryIdentitySmallCircleListComReqDto.setTableTypeCode("OMS_TASK");//sourceId:1680854_1
        queryIdentitySmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1680849_1
        queryIdentitySmallCircleListComReqDto.setIsDisplay("TRUE");//sourceId:1680851_1
        queryIdentitySmallCircleListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1680852_1
        if (reqDto != null) {
            queryIdentitySmallCircleListComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1680846_1
            queryIdentitySmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1680858_1
        }

        /*D3查入参身份人员ID负责的工作任务列表[8803]   */
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getOriginalRoleMemberId(), "D3查询个人工作任务进度排行列表-D3查入参身份人员ID负责的工作任务列表-身份人员ID不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsPersonCharge(), "D3查询个人工作任务进度排行列表-D3查入参身份人员ID负责的工作任务列表-是否负责人不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getTableTypeCode(), "D3查询个人工作任务进度排行列表-D3查入参身份人员ID负责的工作任务列表-冗余内容表类型编码不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsDisplay(), "D3查询个人工作任务进度排行列表-D3查入参身份人员ID负责的工作任务列表-是否外部展示不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getSubjectLifeCycle(), "D3查询个人工作任务进度排行列表-D3查入参身份人员ID负责的工作任务列表-主体生命周期不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getSpaceId(), "D3查询个人工作任务进度排行列表-D3查入参身份人员ID负责的工作任务列表-创建于空间ID不能为空", false);
        queryIdentitySmallCircleListComRespDto = smallCircleCommonService.queryIdentitySmallCircleListCom(queryIdentitySmallCircleListComReqDto)/*vcase invoke isSameApp*/;


//步骤2: 3-7-01批量查询任务进度排行 - batchQueryTaskProgressRank
        List<OmsTask> listOmsTask = new ArrayList<>();
        if (queryIdentitySmallCircleListComRespDto != null) {
            BatchQueryTaskProgressRankReq batchQueryTaskProgressRankReq = new BatchQueryTaskProgressRankReq();
            batchQueryTaskProgressRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1680943_1
            if (queryIdentitySmallCircleListComRespDto != null && queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList() != null && !CollectionUtil.isEmpty(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList())) {
                batchQueryTaskProgressRankReq.setTaskDataList(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item -> item.getEntityId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1680946_1
            }
            if (reqDto != null) {
                batchQueryTaskProgressRankReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1680942_1
                batchQueryTaskProgressRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1680944_1
            }

            /*3-7-01批量查询任务进度排行[8999]   */
            Assert.isNull(batchQueryTaskProgressRankReq.getTaskStatus(), "D3查询个人工作任务进度排行列表-3-7-01批量查询任务进度排行-任务进展状态不能为空", false);
            Assert.isNull(batchQueryTaskProgressRankReq.getSubjectLifeCycle(), "D3查询个人工作任务进度排行列表-3-7-01批量查询任务进度排行-主体生命周期不能为空", false);
            Assert.isNull(batchQueryTaskProgressRankReq.getSpaceId(), "D3查询个人工作任务进度排行列表-3-7-01批量查询任务进度排行-创建于空间ID不能为空", false);
            listOmsTask = mOmsTaskService.batchQueryTaskProgressRank(batchQueryTaskProgressRankReq)/*vcase invoke 本地 method 方法调用;*/;


            listOmsTask_1 = listOmsTask;
        }

        QueryPersonalWorkTaskProgressRankListRespDto retData = new QueryPersonalWorkTaskProgressRankListRespDto();
        retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1681040_1


        return retData;
    }

    /**
     * D3查询个人工作任务逾期排行列表[9001]
     * gen by moon at 4/1/2024, 2:01:25 AM
     */
    @Trace(operationName = "D3查询个人工作任务逾期排行列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryPersonalWorkTaskOverdueRankListRespDto queryPersonalWorkTaskOverdueRankList(QueryPersonalWorkTaskOverdueRankListReqDto reqDto) {


        List<OmsTask> listOmsTask_1 = new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1681060_1
            receptionServiceReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1681064_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681059_1
        }

        /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getOriginalRoleMemberId(), "D3查询个人工作任务逾期排行列表-M3接收入参字段-身份人员ID不能为空", false);
        Assert.isNull(receptionServiceReq.getStateCode(), "D3查询个人工作任务逾期排行列表-M3接收入参字段-内容冗余状态不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询个人工作任务逾期排行列表-M3接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D3查询我身份所在小圈子列表(公共) - queryIdentitySmallCircleListCom
        QueryIdentitySmallCircleListComRespDto queryIdentitySmallCircleListComRespDto = null;
        QueryIdentitySmallCircleListComReqDto queryIdentitySmallCircleListComReqDto = new QueryIdentitySmallCircleListComReqDto();
        queryIdentitySmallCircleListComReqDto.setIsPersonCharge("TRUE");//sourceId:1681070_1
        queryIdentitySmallCircleListComReqDto.setTableTypeCode("OMS_TASK");//sourceId:1681077_1
        queryIdentitySmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1681072_1
        queryIdentitySmallCircleListComReqDto.setIsDisplay("TRUE");//sourceId:1681074_1
        queryIdentitySmallCircleListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1681075_1
        if (reqDto != null) {
            queryIdentitySmallCircleListComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1681069_1
            queryIdentitySmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681081_1
        }

        /*D3查入参身份人员ID负责的工作任务列表[8803]   */
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getOriginalRoleMemberId(), "D3查询个人工作任务逾期排行列表-D3查入参身份人员ID负责的工作任务列表-身份人员ID不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsPersonCharge(), "D3查询个人工作任务逾期排行列表-D3查入参身份人员ID负责的工作任务列表-是否负责人不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getTableTypeCode(), "D3查询个人工作任务逾期排行列表-D3查入参身份人员ID负责的工作任务列表-冗余内容表类型编码不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getUseScene(), "D3查询个人工作任务逾期排行列表-D3查入参身份人员ID负责的工作任务列表-虚拟组织使用场景不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsDisplay(), "D3查询个人工作任务逾期排行列表-D3查入参身份人员ID负责的工作任务列表-是否外部展示不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getSubjectLifeCycle(), "D3查询个人工作任务逾期排行列表-D3查入参身份人员ID负责的工作任务列表-主体生命周期不能为空", false);
        Assert.isNull(queryIdentitySmallCircleListComReqDto.getSpaceId(), "D3查询个人工作任务逾期排行列表-D3查入参身份人员ID负责的工作任务列表-创建于空间ID不能为空", false);
        queryIdentitySmallCircleListComRespDto = smallCircleCommonService.queryIdentitySmallCircleListCom(queryIdentitySmallCircleListComReqDto)/*vcase invoke isSameApp*/;


//步骤2: 3-7-01批量查询任务逾期排行 - batchQueryTaskExpiedRank
        List<OmsTask> listOmsTask = new ArrayList<>();
        if (queryIdentitySmallCircleListComRespDto != null) {
            BatchQueryTaskExpiedRankReq batchQueryTaskExpiedRankReq = new BatchQueryTaskExpiedRankReq();
            batchQueryTaskExpiedRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1681090_1
            if (queryIdentitySmallCircleListComRespDto != null && queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList() != null && !CollectionUtil.isEmpty(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList())) {
                batchQueryTaskExpiedRankReq.setTaskDataList(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item -> item.getEntityId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1681087_1
            }
            if (reqDto != null) {
                batchQueryTaskExpiedRankReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1681089_1
                batchQueryTaskExpiedRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681091_1
            }

            /*3-7-01批量查询任务逾期排行[9002]   */
            Assert.isNull(batchQueryTaskExpiedRankReq.getStateCode(), "D3查询个人工作任务逾期排行列表-3-7-01批量查询任务逾期排行-内容冗余状态不能为空", false);
            Assert.isNull(batchQueryTaskExpiedRankReq.getSubjectLifeCycle(), "D3查询个人工作任务逾期排行列表-3-7-01批量查询任务逾期排行-主体生命周期不能为空", false);
            Assert.isNull(batchQueryTaskExpiedRankReq.getSpaceId(), "D3查询个人工作任务逾期排行列表-3-7-01批量查询任务逾期排行-创建于空间ID不能为空", false);
            listOmsTask = mOmsTaskService.batchQueryTaskExpiedRank(batchQueryTaskExpiedRankReq)/*vcase invoke 本地 method 方法调用;*/;


            listOmsTask_1 = listOmsTask;
        }

        QueryPersonalWorkTaskOverdueRankListRespDto retData = new QueryPersonalWorkTaskOverdueRankListRespDto();
        retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1681092_1


        return retData;
    }

    /**
     * D3查询主管下属问题超时排行列表[9024]
     * gen by moon at 4/1/2024, 2:01:38 AM
     */
    @Trace(operationName = "D3查询主管下属问题超时排行列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryChargeSubQuestionTimeoutRankListRespDto queryChargeSubQuestionTimeoutRankList(QueryChargeSubQuestionTimeoutRankListReqDto reqDto) {


        List<OmsQuestion> listOmsQuestion_1 = new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:1683276_1
            receptionServiceReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1683305_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1683304_1
        }

        /*M3接收字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getDirectorInductionRecordId(), "D3查询主管下属问题超时排行列表-M3接收字段-可选主管就职记录ID不能为空", false);
        Assert.isNull(receptionServiceReq.getQuestionStatus(), "D3查询主管下属问题超时排行列表-M3接收字段-问题状态不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询主管下属问题超时排行列表-M3接收字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D3查询主管我下属小圈子列表(公共) - queryChargeSubordinateSmallCircleListCom
        QueryChargeSubordinateSmallCircleListComRespDto queryChargeSubordinateSmallCircleListComRespDto = null;
        QueryChargeSubordinateSmallCircleListComReqDto queryChargeSubordinateSmallCircleListComReqDto = new QueryChargeSubordinateSmallCircleListComReqDto();
        queryChargeSubordinateSmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1683116_1
        queryChargeSubordinateSmallCircleListComReqDto.setIsPersonCharge("TRUE");//sourceId:1683117_1
        queryChargeSubordinateSmallCircleListComReqDto.setTableTypeCode("OMS_QUESTION");//sourceId:1683118_1
        if (reqDto != null) {
            queryChargeSubordinateSmallCircleListComReqDto.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:1683115_1
            queryChargeSubordinateSmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1683120_1
        }

        /*D3查询主管我下属小圈子列表(公共)[9034]   */
        Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getDirectorInductionRecordId(), "D3查询主管下属问题超时排行列表-D3查询主管我下属小圈子列表(公共)-可选主管就职记录ID不能为空", false);
        Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getUseScene(), "D3查询主管下属问题超时排行列表-D3查询主管我下属小圈子列表(公共)-虚拟组织使用场景不能为空", false);
        Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getIsPersonCharge(), "D3查询主管下属问题超时排行列表-D3查询主管我下属小圈子列表(公共)-是否负责人不能为空", false);
        Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getTableTypeCode(), "D3查询主管下属问题超时排行列表-D3查询主管我下属小圈子列表(公共)-冗余内容表类型编码不能为空", false);
        Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getSpaceId(), "D3查询主管下属问题超时排行列表-D3查询主管我下属小圈子列表(公共)-创建于空间ID不能为空", false);
        queryChargeSubordinateSmallCircleListComRespDto = smallCircleCommonService.queryChargeSubordinateSmallCircleListCom(queryChargeSubordinateSmallCircleListComReqDto)/*vcase invoke isSameApp*/;


//步骤2: 3-7-02批量查询问题超时排行 - batchQueryQuestionTimeoutRank
        List<OmsQuestion> listOmsQuestion = new ArrayList<>();
        if (queryChargeSubordinateSmallCircleListComRespDto != null) {
            BatchQueryQuestionTimeoutRankReq batchQueryQuestionTimeoutRankReq = new BatchQueryQuestionTimeoutRankReq();
            batchQueryQuestionTimeoutRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1683124_1
            if (queryChargeSubordinateSmallCircleListComRespDto != null && queryChargeSubordinateSmallCircleListComRespDto.getVirtualOrgMemberList() != null && !CollectionUtil.isEmpty(queryChargeSubordinateSmallCircleListComRespDto.getVirtualOrgMemberList())) {
                batchQueryQuestionTimeoutRankReq.setQuestionList(queryChargeSubordinateSmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item -> item.getEntityId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1683122_1
            }
            if (reqDto != null) {
                batchQueryQuestionTimeoutRankReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1683123_1
                batchQueryQuestionTimeoutRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1683125_1
            }

            /*3-7-02批量查询问题超时排行[9006]   */
            Assert.isNull(batchQueryQuestionTimeoutRankReq.getQuestionStatus(), "D3查询主管下属问题超时排行列表-3-7-02批量查询问题超时排行-问题状态不能为空", false);
            Assert.isNull(batchQueryQuestionTimeoutRankReq.getSubjectLifeCycle(), "D3查询主管下属问题超时排行列表-3-7-02批量查询问题超时排行-主体生命周期不能为空", false);
            Assert.isNull(batchQueryQuestionTimeoutRankReq.getSpaceId(), "D3查询主管下属问题超时排行列表-3-7-02批量查询问题超时排行-创建于空间ID不能为空", false);
            listOmsQuestion = mOmsQuestionService.batchQueryQuestionTimeoutRank(batchQueryQuestionTimeoutRankReq)/*vcase invoke 本地 method 方法调用;*/;


            listOmsQuestion_1 = listOmsQuestion;
        }

        QueryChargeSubQuestionTimeoutRankListRespDto retData = new QueryChargeSubQuestionTimeoutRankListRespDto();
        retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1683310_1


        return retData;
    }

    /**
     * D3查询项目下任务进度排行列表(公共)[8962]
     * gen by moon at 4/2/2024, 6:51:24 PM
     */
    @Trace(operationName = "D3查询项目下任务进度排行列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryUnderProjectTaskProgressRankListComRespDto queryUnderProjectTaskProgressRankListCom(QueryUnderProjectTaskProgressRankListComReqDto reqDto) {


        QueryTaskProgressRankListComRespDto queryTaskProgressRankListComRespDto_1 = null;
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1687459_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687460_1
        }

        /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getTaskId(), "D3查询项目下任务进度排行列表(公共)-M3接收入参字段-任务ID不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询项目下任务进度排行列表(公共)-M3接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D3查询任务进度排行列表(公共) - queryTaskProgressRankListCom
        QueryTaskProgressRankListComRespDto queryTaskProgressRankListComRespDto = null;
        QueryTaskProgressRankListComReqDto queryTaskProgressRankListComReqDto = new QueryTaskProgressRankListComReqDto();
        queryTaskProgressRankListComReqDto.setWorkTaskType("INDEPENDENT_TASK");//sourceId:1687453_1
        queryTaskProgressRankListComReqDto.setTaskStatus("ONGOING");//sourceId:1687454_1
        queryTaskProgressRankListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1687456_1
        if (reqDto != null) {
            queryTaskProgressRankListComReqDto.setThemeContentId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1687452_1
            queryTaskProgressRankListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687457_1
        }

        /*D3查询任务进度排行列表(公共)[9077]   */
        Assert.isNull(queryTaskProgressRankListComReqDto.getThemeContentId(), "D3查询项目下任务进度排行列表(公共)-D3查询任务进度排行列表(公共)-主题内容ID不能为空", false);
        Assert.isNull(queryTaskProgressRankListComReqDto.getWorkTaskType(), "D3查询项目下任务进度排行列表(公共)-D3查询任务进度排行列表(公共)-工作任务类别不能为空", false);
        Assert.isNull(queryTaskProgressRankListComReqDto.getTaskStatus(), "D3查询项目下任务进度排行列表(公共)-D3查询任务进度排行列表(公共)-任务进展状态不能为空", false);
        Assert.isNull(queryTaskProgressRankListComReqDto.getSubjectLifeCycle(), "D3查询项目下任务进度排行列表(公共)-D3查询任务进度排行列表(公共)-主体生命周期不能为空", false);
        Assert.isNull(queryTaskProgressRankListComReqDto.getSpaceId(), "D3查询项目下任务进度排行列表(公共)-D3查询任务进度排行列表(公共)-创建于空间ID不能为空", false);
        queryTaskProgressRankListComRespDto = queryTaskProgressRankListCom(queryTaskProgressRankListComReqDto)/*vcase invoke 同服务,同domain*/;


        queryTaskProgressRankListComRespDto_1 = queryTaskProgressRankListComRespDto;

        QueryUnderProjectTaskProgressRankListComRespDto retData = new QueryUnderProjectTaskProgressRankListComRespDto();
        if (queryTaskProgressRankListComRespDto_1 != null) {
            retData.setTaskDataList(queryTaskProgressRankListComRespDto_1.getTaskDataList().stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687463_1
        }


        return retData;
    }

    /**
     * D3查询重点关注任务进度排行列表(公共)[8977]
     * gen by moon at 4/2/2024, 6:51:26 PM
     */
    @Trace(operationName = "D3查询重点关注任务进度排行列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryKeyFocusWorkTaskProgressRankListComRespDto queryKeyFocusWorkTaskProgressRankListCom(QueryKeyFocusWorkTaskProgressRankListComReqDto reqDto) {


        BatchQueryTaskProgressRankComRespDto batchQueryTaskProgressRankComRespDto_1 = null;
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setFocusObjectId(reqDto.getFocusObjectId());//SimpleFieldAssign//sourceId:1687833_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687835_1
        }

        /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getFocusObjectId(), "D3查询重点关注任务进度排行列表(公共)-M3接收入参字段-关注主体ID不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询重点关注任务进度排行列表(公共)-M3接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D3查询重点关注列表(公共) - queryKeyFocusListCom
        QueryKeyFocusListComRespDto queryKeyFocusListComRespDto = null;
        QueryKeyFocusListComReqDto queryKeyFocusListComReqDto = new QueryKeyFocusListComReqDto();
        queryKeyFocusListComReqDto.setKeyFocusContentTypeCode("OMS_TASK");//sourceId:1677715_1
        if (reqDto != null) {
            queryKeyFocusListComReqDto.setFocusObjectId(reqDto.getFocusObjectId());//SimpleFieldAssign//sourceId:1677701_1
            queryKeyFocusListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1677717_1
        }

        /*D3查询重点关注列表(公共)[8880]   */
        Assert.isNull(queryKeyFocusListComReqDto.getFocusObjectId(), "D3查询重点关注任务进度排行列表(公共)-D3查询重点关注列表(公共)-关注主体ID不能为空", false);
        Assert.isNull(queryKeyFocusListComReqDto.getKeyFocusContentTypeCode(), "D3查询重点关注任务进度排行列表(公共)-D3查询重点关注列表(公共)-重点关注内容表类型编码不能为空", false);
        Assert.isNull(queryKeyFocusListComReqDto.getSpaceId(), "D3查询重点关注任务进度排行列表(公共)-D3查询重点关注列表(公共)-创建于空间ID不能为空", false);
        queryKeyFocusListComRespDto = dashboardTargetContentService.queryKeyFocusListCom(queryKeyFocusListComReqDto)/*vcase invoke isSameApp*/;


//步骤2: D3批量查询任务进度排行(公共) - batchQueryTaskProgressRankCom
        BatchQueryTaskProgressRankComRespDto batchQueryTaskProgressRankComRespDto = null;
        if (queryKeyFocusListComRespDto != null) {
            BatchQueryTaskProgressRankComReqDto batchQueryTaskProgressRankComReqDto = new BatchQueryTaskProgressRankComReqDto();
            batchQueryTaskProgressRankComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1686896_1
            if (queryKeyFocusListComRespDto != null && queryKeyFocusListComRespDto.getKeyFocusList() != null && !CollectionUtil.isEmpty(queryKeyFocusListComRespDto.getKeyFocusList())) {
                batchQueryTaskProgressRankComReqDto.setTaskDataList(queryKeyFocusListComRespDto.getKeyFocusList().stream().map(item -> item.getKeyFocusContentId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1686894_1
            }
            if (reqDto != null) {
                batchQueryTaskProgressRankComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1686897_1
            }

            /*D3批量查询任务进度排行(公共)[9072]   */
            Assert.isNull(batchQueryTaskProgressRankComReqDto.getSubjectLifeCycle(), "D3查询重点关注任务进度排行列表(公共)-D3批量查询任务进度排行(公共)-主体生命周期不能为空", false);
            Assert.isNull(batchQueryTaskProgressRankComReqDto.getSpaceId(), "D3查询重点关注任务进度排行列表(公共)-D3批量查询任务进度排行(公共)-创建于空间ID不能为空", false);
            batchQueryTaskProgressRankComRespDto = batchQueryTaskProgressRankCom(batchQueryTaskProgressRankComReqDto)/*vcase invoke 同服务,同domain*/;


            batchQueryTaskProgressRankComRespDto_1 = batchQueryTaskProgressRankComRespDto;
        }

        QueryKeyFocusWorkTaskProgressRankListComRespDto retData = new QueryKeyFocusWorkTaskProgressRankListComRespDto();
        if (batchQueryTaskProgressRankComRespDto_1 != null) {
            retData.setTaskDataList(batchQueryTaskProgressRankComRespDto_1.getTaskDataList().stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1686904_1
        }


        return retData;
    }

    /**
     * D3批量查询任务进度排行(公共)[9072]
     * gen by moon at 4/2/2024, 6:23:05 PM
     */
    @Trace(operationName = "D3批量查询任务进度排行(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchQueryTaskProgressRankComRespDto batchQueryTaskProgressRankCom(BatchQueryTaskProgressRankComReqDto reqDto) {


        List<OmsTask> listOmsTask_1 = new ArrayList<>();
//步骤0: 3-7-01批量查询任务进度排行 - batchQueryTaskProgressRank
        List<OmsTask> listOmsTask = new ArrayList<>();
        BatchQueryTaskProgressRankReq batchQueryTaskProgressRankReq = new BatchQueryTaskProgressRankReq();
        if (reqDto != null) {
            batchQueryTaskProgressRankReq.setTaskDataList(reqDto.getTaskDataList());//list-field-assign//sourceId:1686873_1
            batchQueryTaskProgressRankReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1686869_1
            batchQueryTaskProgressRankReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1686870_1
            batchQueryTaskProgressRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1686871_1
        }

        /*3-7-01批量查询任务进度排行[8999]   */
        Assert.isNull(batchQueryTaskProgressRankReq.getSubjectLifeCycle(), "D3批量查询任务进度排行(公共)-3-7-01批量查询任务进度排行-主体生命周期不能为空", false);
        Assert.isNull(batchQueryTaskProgressRankReq.getSpaceId(), "D3批量查询任务进度排行(公共)-3-7-01批量查询任务进度排行-创建于空间ID不能为空", false);
        listOmsTask = mOmsTaskService.batchQueryTaskProgressRank(batchQueryTaskProgressRankReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsTask_1 = listOmsTask;

        BatchQueryTaskProgressRankComRespDto retData = new BatchQueryTaskProgressRankComRespDto();
        retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1686890_1


        return retData;
    }

    /**
     * D3查询任务逾期排行列表(公共)[9073]
     * gen by moon at 4/2/2024, 6:23:19 PM
     */
    @Trace(operationName = "D3查询任务逾期排行列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryTaskExpiedRankListComRespDto queryTaskExpiedRankListCom(QueryTaskExpiedRankListComReqDto reqDto) {


        List<OmsTask> listOmsTask_1 = new ArrayList<>();
//步骤0: 3-7-01查询任务逾期排行列表 - queryTaskExpiedRankList
        List<OmsTask> listOmsTask = new ArrayList<>();
        QueryTaskExpiedRankListReq queryTaskExpiedRankListReq = new QueryTaskExpiedRankListReq();
        if (reqDto != null) {
            queryTaskExpiedRankListReq.setWorkTaskType(reqDto.getWorkTaskType());//SimpleFieldAssign//sourceId:1687125_1
            queryTaskExpiedRankListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1687126_1
            queryTaskExpiedRankListReq.setBizSceneCode(reqDto.getBizSceneCode());//SimpleFieldAssign//sourceId:1687127_1
            queryTaskExpiedRankListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1687128_1
            queryTaskExpiedRankListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687129_1
        }

        /*3-7-01查询任务逾期排行列表[9076]   */
        Assert.isNull(queryTaskExpiedRankListReq.getSubjectLifeCycle(), "D3查询任务逾期排行列表(公共)-3-7-01查询任务逾期排行列表-主体生命周期不能为空", false);
        Assert.isNull(queryTaskExpiedRankListReq.getSpaceId(), "D3查询任务逾期排行列表(公共)-3-7-01查询任务逾期排行列表-创建于空间ID不能为空", false);
        listOmsTask = mOmsTaskService.queryTaskExpiedRankList(queryTaskExpiedRankListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsTask_1 = listOmsTask;

        QueryTaskExpiedRankListComRespDto retData = new QueryTaskExpiedRankListComRespDto();
        retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687135_1


        return retData;
    }

    /**
     * D3查询项目下逾期任务排行列表[9074]
     * gen by moon at 4/2/2024, 6:23:33 PM
     */
    @Trace(operationName = "D3查询项目下逾期任务排行列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryUnderProjectExpiedTaskRankListRespDto queryUnderProjectExpiedTaskRankList(QueryUnderProjectExpiedTaskRankListReqDto reqDto) {


        QueryTaskExpiedRankListComRespDto queryTaskExpiedRankListComRespDto_1 = null;
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1687110_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687111_1
        }

        /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getTaskId(), "D3查询项目下逾期任务排行列表-M3接收入参字段-任务ID不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询项目下逾期任务排行列表-M3接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D3查询任务逾期排行列表(公共) - queryTaskExpiedRankListCom
        QueryTaskExpiedRankListComRespDto queryTaskExpiedRankListComRespDto = null;
        QueryTaskExpiedRankListComReqDto queryTaskExpiedRankListComReqDto = new QueryTaskExpiedRankListComReqDto();
        queryTaskExpiedRankListComReqDto.setWorkTaskType("INDEPENDENT_TASK");//sourceId:1687136_1
        queryTaskExpiedRankListComReqDto.setBizSceneCode("WORK_TASK");//CUSTOM_CONVENTION//sourceId:1687138_1
        queryTaskExpiedRankListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1687139_1
        if (reqDto != null) {
            queryTaskExpiedRankListComReqDto.setThemeContentId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1687137_1
            queryTaskExpiedRankListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687140_1
        }

        /*D3查询任务逾期排行列表(公共)[9073]   */
        Assert.isNull(queryTaskExpiedRankListComReqDto.getThemeContentId(), "D3查询项目下逾期任务排行列表-D3查询任务逾期排行列表(公共)-主题内容ID不能为空", false);
        Assert.isNull(queryTaskExpiedRankListComReqDto.getWorkTaskType(), "D3查询项目下逾期任务排行列表-D3查询任务逾期排行列表(公共)-工作任务类别不能为空", false);
        Assert.isNull(queryTaskExpiedRankListComReqDto.getBizSceneCode(), "D3查询项目下逾期任务排行列表-D3查询任务逾期排行列表(公共)-业务场景编码不能为空", false);
        Assert.isNull(queryTaskExpiedRankListComReqDto.getSubjectLifeCycle(), "D3查询项目下逾期任务排行列表-D3查询任务逾期排行列表(公共)-主体生命周期不能为空", false);
        Assert.isNull(queryTaskExpiedRankListComReqDto.getSpaceId(), "D3查询项目下逾期任务排行列表-D3查询任务逾期排行列表(公共)-创建于空间ID不能为空", false);
        queryTaskExpiedRankListComRespDto = queryTaskExpiedRankListCom(queryTaskExpiedRankListComReqDto)/*vcase invoke 同服务,同domain*/;


        queryTaskExpiedRankListComRespDto_1 = queryTaskExpiedRankListComRespDto;

        QueryUnderProjectExpiedTaskRankListRespDto retData = new QueryUnderProjectExpiedTaskRankListRespDto();
        if (queryTaskExpiedRankListComRespDto_1 != null) {
            retData.setWorkTaskList(queryTaskExpiedRankListComRespDto_1.getTaskDataList().stream().map(item -> BeanUtil.toBean(item, WorkTaskDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687142_1
        }


        return retData;
    }

    /**
     * D3查询任务进度排行列表(公共)[9077]
     * gen by moon at 4/2/2024, 6:23:48 PM
     */
    @Trace(operationName = "D3查询任务进度排行列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryTaskProgressRankListComRespDto queryTaskProgressRankListCom(QueryTaskProgressRankListComReqDto reqDto) {


        List<OmsTask> listOmsTask_1 = new ArrayList<>();
//步骤0: 3-4-07查询任务进度排行列表(公共) - queryTaskProgressRankListCom
        List<OmsTask> listOmsTask = new ArrayList<>();
        QueryTaskProgressRankListComReq queryTaskProgressRankListComReq = new QueryTaskProgressRankListComReq();
        if (reqDto != null) {
            queryTaskProgressRankListComReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1687427_1
            queryTaskProgressRankListComReq.setWorkTaskType(reqDto.getWorkTaskType());//SimpleFieldAssign//sourceId:1687426_1
            queryTaskProgressRankListComReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1687428_1
            queryTaskProgressRankListComReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1687429_1
            queryTaskProgressRankListComReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1687430_1
            queryTaskProgressRankListComReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687431_1
        }

        /*3-4-07查询任务进度排行列表(公共)[9078]   */
        Assert.isNull(queryTaskProgressRankListComReq.getSubjectLifeCycle(), "D3查询任务进度排行列表(公共)-3-4-07查询任务进度排行列表(公共)-主体生命周期不能为空", false);
        Assert.isNull(queryTaskProgressRankListComReq.getSpaceId(), "D3查询任务进度排行列表(公共)-3-4-07查询任务进度排行列表(公共)-创建于空间ID不能为空", false);
        listOmsTask = mOmsTaskService.queryTaskProgressRankListCom(queryTaskProgressRankListComReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsTask_1 = listOmsTask;

        QueryTaskProgressRankListComRespDto retData = new QueryTaskProgressRankListComRespDto();
        retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687451_1


        return retData;
    }

    /**
     * D3查询问题超时排行列表(公共)[9081]
     * gen by moon at 4/2/2024, 6:24:02 PM
     */
    @Trace(operationName = "D3查询问题超时排行列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryQuestionTimeoutRankListComRespDto queryQuestionTimeoutRankListCom(QueryQuestionTimeoutRankListComReqDto reqDto) {


        List<OmsQuestion> listOmsQuestion_1 = new ArrayList<>();
//步骤0: 3-7-02查询问题超时排行列表 - queryQuestionTimeoutRankList
        List<OmsQuestion> listOmsQuestion = new ArrayList<>();
        QueryQuestionTimeoutRankListReq queryQuestionTimeoutRankListReq = new QueryQuestionTimeoutRankListReq();
        if (reqDto != null) {
            queryQuestionTimeoutRankListReq.setParentEntityId(reqDto.getParentEntityId());//SimpleFieldAssign//sourceId:1687502_1
            queryQuestionTimeoutRankListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1687499_1
            queryQuestionTimeoutRankListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1687500_1
            queryQuestionTimeoutRankListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687501_1
        }

        /*3-7-02查询问题超时排行列表[9079]   */
        Assert.isNull(queryQuestionTimeoutRankListReq.getSubjectLifeCycle(), "D3查询问题超时排行列表(公共)-3-7-02查询问题超时排行列表-主体生命周期不能为空", false);
        Assert.isNull(queryQuestionTimeoutRankListReq.getSpaceId(), "D3查询问题超时排行列表(公共)-3-7-02查询问题超时排行列表-创建于空间ID不能为空", false);
        listOmsQuestion = mOmsQuestionService.queryQuestionTimeoutRankList(queryQuestionTimeoutRankListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsQuestion_1 = listOmsQuestion;

        QueryQuestionTimeoutRankListComRespDto retData = new QueryQuestionTimeoutRankListComRespDto();
        retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687511_1


        return retData;
    }

    /**
     * D3查询问题解决天数排行列表(公共)[9082]
     * gen by moon at 4/2/2024, 6:24:16 PM
     */
    @Trace(operationName = "D3查询问题解决天数排行列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryQuestionSolvesRankListComRespDto queryQuestionSolvesRankListCom(QueryQuestionSolvesRankListComReqDto reqDto) {


        List<OmsQuestion> listOmsQuestion_1 = new ArrayList<>();
//步骤0: 3-7-02查询问题解决天数排行列表 - queryQuestionSolvesRankList
        List<OmsQuestion> listOmsQuestion = new ArrayList<>();
        QueryQuestionSolvesRankListReq queryQuestionSolvesRankListReq = new QueryQuestionSolvesRankListReq();
        if (reqDto != null) {
            queryQuestionSolvesRankListReq.setParentEntityId(reqDto.getParentEntityId());//SimpleFieldAssign//sourceId:1687864_1
            queryQuestionSolvesRankListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1687865_1
            queryQuestionSolvesRankListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1687866_1
            queryQuestionSolvesRankListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687867_1
        }

        /*3-7-02查询问题解决天数排行列表[9080]   */
        Assert.isNull(queryQuestionSolvesRankListReq.getSubjectLifeCycle(), "D3查询问题解决天数排行列表(公共)-3-7-02查询问题解决天数排行列表-主体生命周期不能为空", false);
        Assert.isNull(queryQuestionSolvesRankListReq.getSpaceId(), "D3查询问题解决天数排行列表(公共)-3-7-02查询问题解决天数排行列表-创建于空间ID不能为空", false);
        listOmsQuestion = mOmsQuestionService.queryQuestionSolvesRankList(queryQuestionSolvesRankListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsQuestion_1 = listOmsQuestion;

        QueryQuestionSolvesRankListComRespDto retData = new QueryQuestionSolvesRankListComRespDto();
        retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687888_1


        return retData;
    }

    /**
     * D3查询重点关注任务逾期排行列表[9084]
     * gen by moon at 4/2/2024, 6:51:39 PM
     */
    @Trace(operationName = "D3查询重点关注任务逾期排行列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryKeyFocusWorkExpiedTaskRankListRespDto queryKeyFocusWorkExpiedTaskRankList(QueryKeyFocusWorkExpiedTaskRankListReqDto reqDto) {


        BatchQueryTaskExpiedRankComRespDto batchQueryTaskExpiedRankComRespDto_1 = null;
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setFocusObjectId(reqDto.getFocusObjectId());//SimpleFieldAssign//sourceId:1687863_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687869_1
        }

        /*M3接收字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getFocusObjectId(), "D3查询重点关注任务逾期排行列表-M3接收字段-关注主体ID不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询重点关注任务逾期排行列表-M3接收字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//步骤1: D3查询重点关注列表(公共) - queryKeyFocusListCom
        QueryKeyFocusListComRespDto queryKeyFocusListComRespDto = null;
        QueryKeyFocusListComReqDto queryKeyFocusListComReqDto = new QueryKeyFocusListComReqDto();
        queryKeyFocusListComReqDto.setKeyFocusContentTypeCode("OMS_TASK");//sourceId:1687894_1
        if (reqDto != null) {
            queryKeyFocusListComReqDto.setFocusObjectId(reqDto.getFocusObjectId());//SimpleFieldAssign//sourceId:1687883_1
            queryKeyFocusListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687886_1
        }

        /*D3查询重点关注列表(公共)[8880]   */
        Assert.isNull(queryKeyFocusListComReqDto.getFocusObjectId(), "D3查询重点关注任务逾期排行列表-D3查询重点关注列表(公共)-关注主体ID不能为空", false);
        Assert.isNull(queryKeyFocusListComReqDto.getKeyFocusContentTypeCode(), "D3查询重点关注任务逾期排行列表-D3查询重点关注列表(公共)-重点关注内容表类型编码不能为空", false);
        Assert.isNull(queryKeyFocusListComReqDto.getSpaceId(), "D3查询重点关注任务逾期排行列表-D3查询重点关注列表(公共)-创建于空间ID不能为空", false);
        queryKeyFocusListComRespDto = dashboardTargetContentService.queryKeyFocusListCom(queryKeyFocusListComReqDto)/*vcase invoke isSameApp*/;


//步骤2: D3批量查询任务逾期排行(公共) - batchQueryTaskExpiedRankCom
        BatchQueryTaskExpiedRankComRespDto batchQueryTaskExpiedRankComRespDto = null;
        if (queryKeyFocusListComRespDto != null) {
            BatchQueryTaskExpiedRankComReqDto batchQueryTaskExpiedRankComReqDto = new BatchQueryTaskExpiedRankComReqDto();
            batchQueryTaskExpiedRankComReqDto.setStateCode("OVERDUE");//sourceId:1687920_1
            batchQueryTaskExpiedRankComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1687921_1
            if (queryKeyFocusListComRespDto != null && queryKeyFocusListComRespDto.getKeyFocusList() != null && !CollectionUtil.isEmpty(queryKeyFocusListComRespDto.getKeyFocusList())) {
                batchQueryTaskExpiedRankComReqDto.setTaskDataList(queryKeyFocusListComRespDto.getKeyFocusList().stream().map(item -> item.getKeyFocusContentId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1687919_1
            }
            if (reqDto != null) {
                batchQueryTaskExpiedRankComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687922_1
            }

            /*D3批量查询任务逾期排行(公共)[9086]   */
            Assert.isNull(batchQueryTaskExpiedRankComReqDto.getSpaceId(), "D3查询重点关注任务逾期排行列表-D3批量查询任务逾期排行(公共)-创建于空间ID不能为空", false);
            batchQueryTaskExpiedRankComRespDto = batchQueryTaskExpiedRankCom(batchQueryTaskExpiedRankComReqDto)/*vcase invoke 同服务,同domain*/;


            batchQueryTaskExpiedRankComRespDto_1 = batchQueryTaskExpiedRankComRespDto;
        }

        QueryKeyFocusWorkExpiedTaskRankListRespDto retData = new QueryKeyFocusWorkExpiedTaskRankListRespDto();
        if (batchQueryTaskExpiedRankComRespDto_1 != null) {
            retData.setTaskDataList(batchQueryTaskExpiedRankComRespDto_1.getTaskDataList().stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687929_1
        }


        return retData;
    }

    /**
     * D3批量查询任务逾期排行(公共)[9086]
     * gen by moon at 4/2/2024, 6:24:43 PM
     */
    @Trace(operationName = "D3批量查询任务逾期排行(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchQueryTaskExpiedRankComRespDto batchQueryTaskExpiedRankCom(BatchQueryTaskExpiedRankComReqDto reqDto) {


        List<OmsTask> listOmsTask_1 = new ArrayList<>();
//步骤0: 3-7-01批量查询任务逾期排行 - batchQueryTaskExpiedRank
        List<OmsTask> listOmsTask = new ArrayList<>();
        BatchQueryTaskExpiedRankReq batchQueryTaskExpiedRankReq = new BatchQueryTaskExpiedRankReq();
        if (reqDto != null) {
            batchQueryTaskExpiedRankReq.setTaskDataList(reqDto.getTaskDataList());//list-field-assign//sourceId:1687909_1
            batchQueryTaskExpiedRankReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1687911_1
            batchQueryTaskExpiedRankReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1687912_1
            batchQueryTaskExpiedRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687913_1
        }

        /*3-7-01批量查询任务逾期排行[9002]   */
        Assert.isNull(batchQueryTaskExpiedRankReq.getSpaceId(), "D3批量查询任务逾期排行(公共)-3-7-01批量查询任务逾期排行-创建于空间ID不能为空", false);
        listOmsTask = mOmsTaskService.batchQueryTaskExpiedRank(batchQueryTaskExpiedRankReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsTask_1 = listOmsTask;

        BatchQueryTaskExpiedRankComRespDto retData = new BatchQueryTaskExpiedRankComRespDto();
        retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687918_1


        return retData;
    }

    /**
     * D3查询其他大屏周期名称详情(公共)[8992]
     * gen by moon at 6/16/2024, 8:23:05 PM
     */
    @Trace(operationName = "D3查询其他大屏周期名称详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryOtherDashboardCycleNameDetailComRespDto queryOtherDashboardCycleNameDetailCom(QueryOtherDashboardCycleNameDetailComReqDto reqDto) {


        QueryWorkTaskCycleConfDetailComRespDto queryWorkTaskCycleConfDetailComRespDto_1 = null;
        ImplementElevenReceivingFieldRespDto receptionServiceRes_3 = null;
//virtualUsage M3获取系统当前时间  65812
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        receptionServiceReq.setComTimeField(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1680078_1_65812
        if (reqDto != null) {
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679602_1_65812
        }

        /*M3获取系统当前时间[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3查询其他大屏周期名称详情(公共)-M3获取系统当前时间-创建于空间ID不能为空", false);
        Assert.isNull(receptionServiceReq.getComTimeField(), "D3查询其他大屏周期名称详情(公共)-M3获取系统当前时间-通用时间字段不能为空", false);
        receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);


//virtualUsage D2查询工作任务周期配置(公共)  65810
        QueryWorkTaskCycleConfDetailComRespDto queryWorkTaskCycleConfDetailComRespDto = null;
        QueryWorkTaskCycleConfDetailComReqDto queryWorkTaskCycleConfDetailComReqDto = new QueryWorkTaskCycleConfDetailComReqDto();
        if (reqDto != null) {
            queryWorkTaskCycleConfDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679435_1_65810
        }

        /*D2查询工作任务周期配置(公共)[8984]   */
        Assert.isNull(queryWorkTaskCycleConfDetailComReqDto.getSpaceId(), "D3查询其他大屏周期名称详情(公共)-D2查询工作任务周期配置(公共)-创建于空间ID不能为空", false);
        queryWorkTaskCycleConfDetailComRespDto = fwCompDashboardWorkTaskClient.queryWorkTaskCycleConfDetailCom(queryWorkTaskCycleConfDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        queryWorkTaskCycleConfDetailComRespDto_1 = queryWorkTaskCycleConfDetailComRespDto;
//virtualUsage D3分析租户周期(公共)  70002
        AnalysisTenementCycleComRespDto analysisTenementCycleComRespDto = null;
        if (queryWorkTaskCycleConfDetailComRespDto != null) {
            AnalysisTenementCycleComReqDto analysisTenementCycleComReqDto = new AnalysisTenementCycleComReqDto();
            if (queryWorkTaskCycleConfDetailComRespDto != null) {
                analysisTenementCycleComReqDto.setIsTenementCycle(queryWorkTaskCycleConfDetailComRespDto.getIsTenementCycle());//SimpleFieldAssign//sourceId:1679593_1_70002
            }
            if (reqDto != null) {
                analysisTenementCycleComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679596_1_70002
            }

            /*D3分析租户周期(公共)[8903]   */
            Assert.isNull(analysisTenementCycleComReqDto.getIsTenementCycle(), "D3查询其他大屏周期名称详情(公共)-D3分析租户周期(公共)-是否租户周期不能为空", false);
            Assert.isNull(analysisTenementCycleComReqDto.getSpaceId(), "D3查询其他大屏周期名称详情(公共)-D3分析租户周期(公共)-创建于空间ID不能为空", false);
            analysisTenementCycleComRespDto = cycleTypeService.analysisTenementCycleCom(analysisTenementCycleComReqDto)/*vcase invoke isSameApp*/;


        }
        if ((reqDto != null && reqDto.getCycleStartTime() == null && reqDto != null && reqDto.getCycleEndTime() == null)) {
            //if((D3查询其他大屏周期名称详情(公共).周期开始时间 值等于空  and D3查询其他大屏周期名称详情(公共).周期结束时间 值等于空 ))  70099

            OmsCycle omsCycle = null;
            if (queryWorkTaskCycleConfDetailComRespDto != null && analysisTenementCycleComRespDto != null) {
                QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq = new QueryTimeRangeFindCycleDetailReq();
                queryTimeRangeFindCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1866382_1_70101
                if (receptionServiceRes != null) {
                    queryTimeRangeFindCycleDetailReq.setCycleStartTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1866378_1_70101
                    queryTimeRangeFindCycleDetailReq.setCycleEndTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1866379_1_70101
                }
                if (queryWorkTaskCycleConfDetailComRespDto != null) {
                    queryTimeRangeFindCycleDetailReq.setCycleTypeCode(queryWorkTaskCycleConfDetailComRespDto.getWorkCycleTypeCode());//SimpleFieldAssign//sourceId:1866380_1_70101
                }
                if (analysisTenementCycleComRespDto != null) {
                    queryTimeRangeFindCycleDetailReq.setPlatformData(analysisTenementCycleComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:1866381_1_70101
                    queryTimeRangeFindCycleDetailReq.setSpaceId(analysisTenementCycleComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1866390_1_70101
                }

                /*3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）[7005]   */
                Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleStartTime(), "D3查询其他大屏周期名称详情(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期开始时间不能为空", false);
                Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleEndTime(), "D3查询其他大屏周期名称详情(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期结束时间不能为空", false);
                Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleTypeCode(), "D3查询其他大屏周期名称详情(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期类型标识不能为空", false);
                Assert.isNull(queryTimeRangeFindCycleDetailReq.getPlatformData(), "D3查询其他大屏周期名称详情(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否是平台不能为空", false);
                Assert.isNull(queryTimeRangeFindCycleDetailReq.getSubjectLifeCycle(), "D3查询其他大屏周期名称详情(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-主体生命周期不能为空", false);
//Assert.isNull(queryTimeRangeFindCycleDetailReq.getSpaceId(),"D3查询其他大屏周期名称详情(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-创建于空间ID不能为空",false);
                omsCycle = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
                Assert.isTrue(omsCycle == null || omsCycle.getCycleId() == null, "找不到数据，系统异常", false);


            }
//ModelCode: receptionService
            ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
            if (omsCycle != null) {
                ImplementElevenReceivingFieldReqDto receptionServiceReq_1 = new ImplementElevenReceivingFieldReqDto();
                if (omsCycle != null) {
                    receptionServiceReq_1.setCycleId(omsCycle.getCycleId());//SimpleFieldAssign//sourceId:1873445_1_70103
                    receptionServiceReq_1.setCycleStandardName(omsCycle.getCycleStandardName());//SimpleFieldAssign//sourceId:1873447_1_70103
                }

                /*M3接收周期ID出参[9482]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getCycleId(), "D3查询其他大屏周期名称详情(公共)-M3接收周期ID出参-周期ID不能为空", false);
                Assert.isNull(receptionServiceReq_1.getCycleStandardName(), "D3查询其他大屏周期名称详情(公共)-M3接收周期ID出参-周期名称不能为空", false);
                receptionServiceRes_2 = nbDashboardWorkTask.implementElevenReceivingField(receptionServiceReq_1);


                receptionServiceRes_3 = receptionServiceRes_2;
            }
        } else if ((reqDto != null && reqDto.getCycleStartTime() != null && reqDto != null && reqDto.getCycleEndTime() != null)) {
            //elseif((D3查询其他大屏周期名称详情(公共).周期开始时间 值不等于空  and D3查询其他大屏周期名称详情(公共).周期结束时间 值不等于空 ))  70100

            OmsCycle omsCycle_2 = null;
            if (queryWorkTaskCycleConfDetailComRespDto != null && analysisTenementCycleComRespDto != null) {
                QueryCycleByTimeEqualDetailReq queryCycleByTimeEqualDetailReq = new QueryCycleByTimeEqualDetailReq();
                queryCycleByTimeEqualDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1873225_1_70102
                if (reqDto != null) {
                    queryCycleByTimeEqualDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1873221_1_70102
                    queryCycleByTimeEqualDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1873222_1_70102
                }
                if (queryWorkTaskCycleConfDetailComRespDto != null) {
                    queryCycleByTimeEqualDetailReq.setCycleTypeCode(queryWorkTaskCycleConfDetailComRespDto.getWorkCycleTypeCode());//SimpleFieldAssign//sourceId:1873223_1_70102
                }
                if (analysisTenementCycleComRespDto != null) {
                    queryCycleByTimeEqualDetailReq.setPlatformData(analysisTenementCycleComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:1873224_1_70102
                    queryCycleByTimeEqualDetailReq.setSpaceId(analysisTenementCycleComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1873226_1_70102
                }

                /*3-4-04查询周期详情（起止时间等于）[9823]   */
                Assert.isNull(queryCycleByTimeEqualDetailReq.getCycleStartTime(), "D3查询其他大屏周期名称详情(公共)-3-4-04查询周期详情（起止时间等于）-周期开始时间不能为空", false);
                Assert.isNull(queryCycleByTimeEqualDetailReq.getCycleEndTime(), "D3查询其他大屏周期名称详情(公共)-3-4-04查询周期详情（起止时间等于）-周期结束时间不能为空", false);
                Assert.isNull(queryCycleByTimeEqualDetailReq.getCycleTypeCode(), "D3查询其他大屏周期名称详情(公共)-3-4-04查询周期详情（起止时间等于）-周期类型标识不能为空", false);
                Assert.isNull(queryCycleByTimeEqualDetailReq.getPlatformData(), "D3查询其他大屏周期名称详情(公共)-3-4-04查询周期详情（起止时间等于）-是否是平台不能为空", false);
                Assert.isNull(queryCycleByTimeEqualDetailReq.getSubjectLifeCycle(), "D3查询其他大屏周期名称详情(公共)-3-4-04查询周期详情（起止时间等于）-主体生命周期不能为空", false);
//Assert.isNull(queryCycleByTimeEqualDetailReq.getSpaceId(),"D3查询其他大屏周期名称详情(公共)-3-4-04查询周期详情（起止时间等于）-创建于空间ID不能为空",false);
                omsCycle_2 = mOmsCycleService.queryCycleByTimeEqualDetail(queryCycleByTimeEqualDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            }
//ModelCode: receptionService
            ImplementElevenReceivingFieldRespDto receptionServiceRes_4 = null;
            if (omsCycle_2 != null) {
                ImplementElevenReceivingFieldReqDto receptionServiceReq_2 = new ImplementElevenReceivingFieldReqDto();
                if (omsCycle_2 != null) {
                    receptionServiceReq_2.setCycleId(omsCycle_2.getCycleId());//SimpleFieldAssign//sourceId:1873445_1_70104
                    receptionServiceReq_2.setCycleStandardName(omsCycle_2.getCycleStandardName());//SimpleFieldAssign//sourceId:1873447_1_70104
                }

                /*M3接收周期ID出参[9482]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_2.getCycleId(), "D3查询其他大屏周期名称详情(公共)-M3接收周期ID出参-周期ID不能为空", false);
                Assert.isNull(receptionServiceReq_2.getCycleStandardName(), "D3查询其他大屏周期名称详情(公共)-M3接收周期ID出参-周期名称不能为空", false);
                receptionServiceRes_4 = nbDashboardWorkTask.implementElevenReceivingField(receptionServiceReq_2);


                receptionServiceRes_3 = receptionServiceRes_4;
            }
        }
        QueryOtherDashboardCycleNameDetailComRespDto retData = new QueryOtherDashboardCycleNameDetailComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setCycleId(receptionServiceRes_3.getCycleId());//SimpleFieldAssign//sourceId:1873448_1
            retData.setCycleStandardName(receptionServiceRes_3.getCycleStandardName());//SimpleFieldAssign//sourceId:1873449_1
        }
        if (queryWorkTaskCycleConfDetailComRespDto_1 != null) {
            retData.setUpdateCycleTypeCode(queryWorkTaskCycleConfDetailComRespDto_1.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1866391_1
        }


        return retData;
    }

    /**
     * D3查询时间统计任务列表(公共)[10075]
     * gen by moon at 9/15/2024, 7:23:55 PM
     */
    @Trace(operationName = "D3查询时间统计任务列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryTimeStatisticsTasksListComRespDto queryTimeStatisticsTasksListCom(QueryTimeStatisticsTasksListComReqDto reqDto) {


        List<OmsTask> listOmsTask_1 = new ArrayList<>();
//步骤0: 3-7-01查询时间统计任务列表(公共) - queryTimeStatisticsTasksListCom
        List<OmsTask> listOmsTask = new ArrayList<>();
        QueryTimeStatisticsTasksListComReq queryTimeStatisticsTasksListComReq = new QueryTimeStatisticsTasksListComReq();
        if (reqDto != null) {
            queryTimeStatisticsTasksListComReq.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1960843_1
            queryTimeStatisticsTasksListComReq.setPlanEndTime(reqDto.getPlanEndTime());//SimpleFieldAssign//sourceId:1960844_1
            queryTimeStatisticsTasksListComReq.setCoordObjectId(reqDto.getCoordObjectId());//SimpleFieldAssign//sourceId:1960835_1
            queryTimeStatisticsTasksListComReq.setTaskType(reqDto.getTaskType());//SimpleFieldAssign//sourceId:1960833_1
            queryTimeStatisticsTasksListComReq.setWorkTaskType(reqDto.getWorkTaskType());//SimpleFieldAssign//sourceId:1960834_1
            queryTimeStatisticsTasksListComReq.setBizSceneCode(reqDto.getBizSceneCode());//SimpleFieldAssign//sourceId:1960836_1
            queryTimeStatisticsTasksListComReq.setIsAlignment(reqDto.getIsAlignment());//SimpleFieldAssign//sourceId:1960837_1
            queryTimeStatisticsTasksListComReq.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:2002267_1
            queryTimeStatisticsTasksListComReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1960838_1
            queryTimeStatisticsTasksListComReq.setIsOverdue(reqDto.getIsOverdue());//SimpleFieldAssign//sourceId:1988850_1
            queryTimeStatisticsTasksListComReq.setIsComplete(reqDto.getIsComplete());//SimpleFieldAssign//sourceId:1960839_1
            queryTimeStatisticsTasksListComReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1960840_1
            queryTimeStatisticsTasksListComReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1960873_1
            queryTimeStatisticsTasksListComReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1960841_1
            queryTimeStatisticsTasksListComReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2002268_1
            queryTimeStatisticsTasksListComReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1960842_1
        }

        /*3-7-01查询时间统计任务列表(公共)[10074]   */

        listOmsTask = mOmsTaskService.queryTimeStatisticsTasksListCom(queryTimeStatisticsTasksListComReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsTask_1 = listOmsTask;

        QueryTimeStatisticsTasksListComRespDto retData = new QueryTimeStatisticsTasksListComRespDto();
        retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1960858_1


        return retData;
    }

    /**
     * D3批量查询时间统计任务(公共)[10077]
     * gen by moon at 8/8/2024, 9:55:08 AM
     */
    @Trace(operationName = "D3批量查询时间统计任务(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchQueryTimeStatisticsTasksComRespDto batchQueryTimeStatisticsTasksCom(BatchQueryTimeStatisticsTasksComReqDto reqDto) {


        List<OmsTask> listOmsTask_1 = new ArrayList<>();
//步骤0: 3-7-09批量查询时间统计任务 - batchQueryTimeStatisticsTasks
        List<OmsTask> listOmsTask = new ArrayList<>();
        BatchQueryTimeStatisticsTasksReq batchQueryTimeStatisticsTasksReq = new BatchQueryTimeStatisticsTasksReq();
        if (reqDto != null) {
            batchQueryTimeStatisticsTasksReq.setTaskDataList(reqDto.getTaskDataList());//list-field-assign//sourceId:1960900_1
            batchQueryTimeStatisticsTasksReq.setTaskType(reqDto.getTaskType());//SimpleFieldAssign//sourceId:1960901_1
            batchQueryTimeStatisticsTasksReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1960902_1
            batchQueryTimeStatisticsTasksReq.setIsAlignment(reqDto.getIsAlignment());//SimpleFieldAssign//sourceId:1960903_1
            batchQueryTimeStatisticsTasksReq.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1960904_1
            batchQueryTimeStatisticsTasksReq.setPlanEndTime(reqDto.getPlanEndTime());//SimpleFieldAssign//sourceId:1960905_1
            batchQueryTimeStatisticsTasksReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1960906_1
            batchQueryTimeStatisticsTasksReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1960907_1
            batchQueryTimeStatisticsTasksReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1960908_1
            batchQueryTimeStatisticsTasksReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1960909_1
        }

        /*3-7-09批量查询时间统计任务[10076]   */

        listOmsTask = mOmsTaskService.batchQueryTimeStatisticsTasks(batchQueryTimeStatisticsTasksReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsTask_1 = listOmsTask;

        BatchQueryTimeStatisticsTasksComRespDto retData = new BatchQueryTimeStatisticsTasksComRespDto();
        retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1960921_1


        return retData;
    }
    //
}
